/* Define builtin-in macros for the C family front ends.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
- Free Software Foundation, Inc.
+ Copyright (C) 2002-2015 Free Software Foundation, Inc.
This file is part of GCC.
#include "system.h"
#include "coretypes.h"
#include "tm.h"
+#include "alias.h"
+#include "symtab.h"
#include "tree.h"
+#include "stor-layout.h"
+#include "stringpool.h"
#include "version.h"
#include "flags.h"
#include "c-common.h"
#include "c-pragma.h"
-#include "output.h"
+#include "output.h" /* For user_label_prefix. */
#include "debug.h" /* For dwarf2out_do_cfi_asm. */
-#include "toplev.h"
#include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
#include "target.h"
+#include "common/common-target.h"
#include "cpp-id-data.h"
#include "cppbuiltin.h"
#endif
/* Non-static as some targets don't use it. */
-void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
-static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
static void builtin_define_with_hex_fp_value (const char *, tree,
int, const char *,
const char *,
static void builtin_define_constants (const char *, tree);
static void builtin_define_type_max (const char *, tree);
static void builtin_define_type_minmax (const char *, const char *, tree);
-static void builtin_define_type_sizeof (const char *, tree);
static void builtin_define_float_constants (const char *,
const char *,
const char *,
+ const char *,
tree);
+/* Return true if MODE provides a fast multiply/add (FMA) builtin function.
+ Originally this function used the fma optab, but that doesn't work with
+ -save-temps, so just rely on the HAVE_fma macros for the standard floating
+ point types. */
+
+static bool
+mode_has_fma (machine_mode mode)
+{
+ switch (mode)
+ {
+#ifdef HAVE_fmasf4
+ case SFmode:
+ return !!HAVE_fmasf4;
+#endif
+
+#ifdef HAVE_fmadf4
+ case DFmode:
+ return !!HAVE_fmadf4;
+#endif
+
+#ifdef HAVE_fmaxf4
+ case XFmode:
+ return !!HAVE_fmaxf4;
+#endif
+
+#ifdef HAVE_fmatf4
+ case TFmode:
+ return !!HAVE_fmatf4;
+#endif
+
+ default:
+ break;
+ }
+
+ return false;
+}
+
/* Define NAME with value TYPE size_unit. */
-static void
+void
builtin_define_type_sizeof (const char *name, tree type)
{
builtin_define_with_int_value (name,
- tree_low_cst (TYPE_SIZE_UNIT (type), 1));
+ tree_to_uhwi (TYPE_SIZE_UNIT (type)));
}
/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
builtin_define_float_constants (const char *name_prefix,
const char *fp_suffix,
const char *fp_cast,
+ const char *fma_suffix,
tree type)
{
/* Used to convert radix-based values to base 10 values in several cases.
sprintf (buf, "0x1p%d", 1 - fmt->p);
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
- /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
- positive floating-point number, b**(emin-p). Zero for formats that
- don't support denormals. */
+ /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
+ The minimum denormalized positive floating-point number, b**(emin-p).
+ The minimum normalized positive floating-point number for formats
+ that don't support denormals. */
sprintf (name, "__%s_DENORM_MIN__", name_prefix);
- if (fmt->has_denorm)
- {
- sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
- builtin_define_with_hex_fp_value (name, type, decimal_dig,
- buf, fp_suffix, fp_cast);
- }
- else
- {
- sprintf (buf, "0.0%s", fp_suffix);
- builtin_define_with_value (name, buf, 0);
- }
+ sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
+ builtin_define_with_hex_fp_value (name, type, decimal_dig,
+ buf, fp_suffix, fp_cast);
sprintf (name, "__%s_HAS_DENORM__", name_prefix);
builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
NaN has quiet NaNs. */
sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
+
+ /* Note whether we have fast FMA. */
+ if (mode_has_fma (TYPE_MODE (type)))
+ {
+ sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
+ builtin_define_with_int_value (name, 1);
+ }
}
/* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
builtin_define_type_max ("__INT64_MAX__", int64_type_node);
if (uint8_type_node)
builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
- if (uint16_type_node)
- builtin_define_type_max ("__UINT16_MAX__", uint16_type_node);
+ if (c_uint16_type_node)
+ builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
if (c_uint32_type_node)
builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
if (c_uint64_type_node)
else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
cpp_undef (pfile, "__SUPPORT_SNAN__");
+ if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
+ cpp_undef (pfile, "__NO_MATH_ERRNO__");
+ else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
+ cpp_define (pfile, "__NO_MATH_ERRNO__");
+
if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
{
cpp_undef (pfile, "__FINITE_MATH_ONLY__");
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
}
- else if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
+ else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
{
cpp_undef (pfile, "__FINITE_MATH_ONLY__");
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
}
+/* This function will emit cpp macros to indicate the presence of various lock
+ free atomic operations. */
+
+static void
+cpp_atomic_builtins (cpp_reader *pfile)
+{
+ /* Set a flag for each size of object that compare and swap exists for up to
+ a 16 byte object. */
+#define SWAP_LIMIT 17
+ bool have_swap[SWAP_LIMIT];
+ unsigned int psize;
+
+ /* Clear the map of sizes compare_and swap exists for. */
+ memset (have_swap, 0, sizeof (have_swap));
+
+ /* Tell source code if the compiler makes sync_compare_and_swap
+ builtins available. */
+#ifndef HAVE_sync_compare_and_swapqi
+#define HAVE_sync_compare_and_swapqi 0
+#endif
+#ifndef HAVE_atomic_compare_and_swapqi
+#define HAVE_atomic_compare_and_swapqi 0
+#endif
+
+ if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
+ {
+ cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
+ have_swap[1] = true;
+ }
+
+#ifndef HAVE_sync_compare_and_swaphi
+#define HAVE_sync_compare_and_swaphi 0
+#endif
+#ifndef HAVE_atomic_compare_and_swaphi
+#define HAVE_atomic_compare_and_swaphi 0
+#endif
+ if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
+ {
+ cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
+ have_swap[2] = true;
+ }
+
+#ifndef HAVE_sync_compare_and_swapsi
+#define HAVE_sync_compare_and_swapsi 0
+#endif
+#ifndef HAVE_atomic_compare_and_swapsi
+#define HAVE_atomic_compare_and_swapsi 0
+#endif
+ if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
+ {
+ cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
+ have_swap[4] = true;
+ }
+
+#ifndef HAVE_sync_compare_and_swapdi
+#define HAVE_sync_compare_and_swapdi 0
+#endif
+#ifndef HAVE_atomic_compare_and_swapdi
+#define HAVE_atomic_compare_and_swapdi 0
+#endif
+ if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
+ {
+ cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
+ have_swap[8] = true;
+ }
+
+#ifndef HAVE_sync_compare_and_swapti
+#define HAVE_sync_compare_and_swapti 0
+#endif
+#ifndef HAVE_atomic_compare_and_swapti
+#define HAVE_atomic_compare_and_swapti 0
+#endif
+ if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
+ {
+ cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
+ have_swap[16] = true;
+ }
+
+ /* Tell the source code about various types. These map to the C++11 and C11
+ macros where 2 indicates lock-free always, and 1 indicates sometimes
+ lock free. */
+#define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
+#define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
+ builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
+ (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
+ (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
+ (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
+ (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
+ (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
+ (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
+ (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
+ (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
+ builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
+ (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
+
+ /* If we're dealing with a "set" value that doesn't exactly correspond
+ to a boolean truth value, let the library work around that. */
+ builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
+ targetm.atomic_test_and_set_trueval);
+
+ /* 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 or pch. */
+ psize = POINTER_SIZE_UNITS;
+ if (psize >= SWAP_LIMIT)
+ psize = 0;
+ builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
+ (have_swap[psize]? 2 : 1));
+}
+
+/* Return the value for __GCC_IEC_559. */
+static int
+cpp_iec_559_value (void)
+{
+ /* The default is support for IEEE 754-2008. */
+ int ret = 2;
+
+ /* float and double must be binary32 and binary64. If they are but
+ with reversed NaN convention, at most IEEE 754-1985 is
+ supported. */
+ const struct real_format *ffmt
+ = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
+ const struct real_format *dfmt
+ = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
+ if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
+ ret = 1;
+ if (ffmt->b != 2
+ || ffmt->p != 24
+ || ffmt->pnan != 24
+ || ffmt->emin != -125
+ || ffmt->emax != 128
+ || ffmt->signbit_rw != 31
+ || ffmt->round_towards_zero
+ || !ffmt->has_sign_dependent_rounding
+ || !ffmt->has_nans
+ || !ffmt->has_inf
+ || !ffmt->has_denorm
+ || !ffmt->has_signed_zero
+ || dfmt->b != 2
+ || dfmt->p != 53
+ || dfmt->pnan != 53
+ || dfmt->emin != -1021
+ || dfmt->emax != 1024
+ || dfmt->signbit_rw != 63
+ || dfmt->round_towards_zero
+ || !dfmt->has_sign_dependent_rounding
+ || !dfmt->has_nans
+ || !dfmt->has_inf
+ || !dfmt->has_denorm
+ || !dfmt->has_signed_zero)
+ ret = 0;
+
+ /* In strict C standards conformance mode, consider unpredictable
+ excess precision to mean lack of IEEE 754 support. The same
+ applies to unpredictable contraction. For C++, and outside
+ strict conformance mode, do not consider these options to mean
+ lack of IEEE 754 support. */
+ if (flag_iso
+ && !c_dialect_cxx ()
+ && TARGET_FLT_EVAL_METHOD != 0
+ && flag_excess_precision_cmdline != EXCESS_PRECISION_STANDARD)
+ ret = 0;
+ if (flag_iso
+ && !c_dialect_cxx ()
+ && flag_fp_contract_mode == FP_CONTRACT_FAST)
+ ret = 0;
+
+ /* Various options are contrary to IEEE 754 semantics. */
+ if (flag_unsafe_math_optimizations
+ || flag_associative_math
+ || flag_reciprocal_math
+ || flag_finite_math_only
+ || !flag_signed_zeros
+ || flag_single_precision_constant)
+ ret = 0;
+
+ /* If the target does not support IEEE 754 exceptions and rounding
+ modes, consider IEEE 754 support to be absent. */
+ if (!targetm.float_exceptions_rounding_supported_p ())
+ ret = 0;
+
+ return ret;
+}
+
+/* Return the value for __GCC_IEC_559_COMPLEX. */
+static int
+cpp_iec_559_complex_value (void)
+{
+ /* The value is no bigger than that of __GCC_IEC_559. */
+ int ret = cpp_iec_559_value ();
+
+ /* Some options are contrary to the required default state of the
+ CX_LIMITED_RANGE pragma. */
+ if (flag_complex_method != 2)
+ ret = 0;
+
+ return ret;
+}
+
/* Hook that registers front end and target-specific built-ins. */
void
c_cpp_builtins (cpp_reader *pfile)
{
+ int i;
+
/* -undef turns off target-specific built-ins. */
if (flag_undef)
return;
/* 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 == cxx0x)
+ {
+ cpp_define (pfile, "__GXX_RTTI");
+ cpp_define (pfile, "__cpp_rtti=199711");
+ }
+
+ 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");
+
+ /* Arrays of runtime bound were removed from C++14, but we still
+ support GNU VLAs. Let's define this macro to a low number
+ (corresponding to the initial test release of GNU C++) if we won't
+ complain about use of VLAs. */
+ if (c_dialect_cxx ()
+ && (pedantic ? warn_vla == 0 : warn_vla <= 0))
+ cpp_define (pfile, "__cpp_runtime_arrays=198712");
+
+ 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");
+ if (cxx_dialect == cxx11)
+ cpp_define (pfile, "__cpp_constexpr=200704");
+ cpp_define (pfile, "__cpp_range_based_for=200907");
+ 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_initializer_lists=200806");
+ cpp_define (pfile, "__cpp_delegating_constructors=200604");
+ cpp_define (pfile, "__cpp_nsdmi=200809");
+ cpp_define (pfile, "__cpp_inheriting_constructors=200802");
+ cpp_define (pfile, "__cpp_ref_qualifiers=200710");
+ 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_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");
+ }
+ if (flag_sized_deallocation)
+ cpp_define (pfile, "__cpp_sized_deallocation=201309");
}
/* 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");
+ {
+ cpp_define (pfile, "__EXCEPTIONS");
+ if (c_dialect_cxx ())
+ cpp_define (pfile, "__cpp_exceptions=199711");
+ }
/* 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);
+ /* We should have set this to something real in c_common_post_options. */
+ gcc_unreachable ();
else if (flag_abi_version == 1)
/* Due to a historical accident, this version had the value
"102". */
1000 + flag_abi_version);
/* libgcc needs to know this. */
- if (targetm.except_unwind_info () == UI_SJLJ)
+ 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 ("__PTRDIFF_MAX__", ptrdiff_type_node);
builtin_define_type_max ("__SIZE_MAX__", size_type_node);
+ if (c_dialect_cxx ())
+ for (i = 0; i < NUM_INT_N_ENTS; i ++)
+ if (int_n_enabled_p[i])
+ {
+ char buf[35+20+20];
+
+ /* These are used to configure the C++ library. */
+
+ if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
+ {
+ sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
+ cpp_define (parse_in, buf);
+
+ sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
+ cpp_define (parse_in, buf);
+ }
+ }
+
/* 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);
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
TARGET_DEC_EVAL_METHOD);
- builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
+ 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. */
- builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
- builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
+ 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_fixed_point_constants ("UTA", "", uta_type_node);
}
+ /* For libgcc-internal use only. */
+ if (flag_building_libgcc)
+ {
+ /* Properties of floating-point modes for libgcc2.c. */
+ for (machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
+ mode != VOIDmode;
+ mode = GET_MODE_WIDER_MODE (mode))
+ {
+ const char *name = GET_MODE_NAME (mode);
+ char *macro_name
+ = (char *) alloca (strlen (name)
+ + sizeof ("__LIBGCC__MANT_DIG__"));
+ sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
+ builtin_define_with_int_value (macro_name,
+ REAL_MODE_FORMAT (mode)->p);
+ if (!targetm.scalar_mode_supported_p (mode)
+ || !targetm.libgcc_floating_mode_supported_p (mode))
+ continue;
+ macro_name = (char *) alloca (strlen (name)
+ + sizeof ("__LIBGCC_HAS__MODE__"));
+ sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
+ cpp_define (pfile, macro_name);
+ macro_name = (char *) alloca (strlen (name)
+ + sizeof ("__LIBGCC__FUNC_EXT__"));
+ sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
+ const char *suffix;
+ if (mode == TYPE_MODE (double_type_node))
+ suffix = "";
+ else if (mode == TYPE_MODE (float_type_node))
+ suffix = "f";
+ else if (mode == TYPE_MODE (long_double_type_node))
+ suffix = "l";
+ /* ??? The following assumes the built-in functions (defined
+ in target-specific code) match the suffixes used for
+ constants. Because in fact such functions are not
+ defined for the 'w' suffix, 'l' is used there
+ instead. */
+ else if (mode == targetm.c.mode_for_suffix ('q'))
+ suffix = "q";
+ else if (mode == targetm.c.mode_for_suffix ('w'))
+ suffix = "l";
+ else
+ gcc_unreachable ();
+ builtin_define_with_value (macro_name, suffix, 0);
+ bool excess_precision = false;
+ if (TARGET_FLT_EVAL_METHOD != 0
+ && mode != TYPE_MODE (long_double_type_node)
+ && (mode == TYPE_MODE (float_type_node)
+ || mode == TYPE_MODE (double_type_node)))
+ switch (TARGET_FLT_EVAL_METHOD)
+ {
+ case -1:
+ case 2:
+ excess_precision = true;
+ break;
+
+ case 1:
+ excess_precision = mode == TYPE_MODE (float_type_node);
+ break;
+
+ default:
+ gcc_unreachable ();
+ }
+ macro_name = (char *) alloca (strlen (name)
+ + sizeof ("__LIBGCC__EXCESS_"
+ "PRECISION__"));
+ sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
+ builtin_define_with_int_value (macro_name, excess_precision);
+ }
+
+ /* For libgcc crtstuff.c and libgcc2.c. */
+ builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
+ EH_TABLES_CAN_BE_READ_ONLY);
+#ifdef EH_FRAME_SECTION_NAME
+ builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
+ EH_FRAME_SECTION_NAME, 1);
+#endif
+#ifdef JCR_SECTION_NAME
+ builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__",
+ JCR_SECTION_NAME, 1);
+#endif
+#ifdef CTORS_SECTION_ASM_OP
+ builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
+ CTORS_SECTION_ASM_OP, 1);
+#endif
+#ifdef DTORS_SECTION_ASM_OP
+ builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
+ DTORS_SECTION_ASM_OP, 1);
+#endif
+#ifdef TEXT_SECTION_ASM_OP
+ builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
+ TEXT_SECTION_ASM_OP, 1);
+#endif
+#ifdef INIT_SECTION_ASM_OP
+ builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
+ INIT_SECTION_ASM_OP, 1);
+#endif
+#ifdef INIT_ARRAY_SECTION_ASM_OP
+ /* Despite the name of this target macro, the expansion is not
+ actually used, and may be empty rather than a string
+ constant. */
+ cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
+#endif
+
+ /* For libgcc enable-execute-stack.c. */
+ builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
+ TRAMPOLINE_SIZE);
+
+ /* For libgcc generic-morestack.c and unwinder code. */
+ if (STACK_GROWS_DOWNWARD)
+ cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
+
+ /* For libgcc unwinder code. */
+#ifdef DONT_USE_BUILTIN_SETJMP
+ cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
+#endif
+#ifdef DWARF_ALT_FRAME_RETURN_COLUMN
+ builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
+ DWARF_ALT_FRAME_RETURN_COLUMN);
+#endif
+ builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
+ DWARF_FRAME_REGISTERS);
+#ifdef EH_RETURN_STACKADJ_RTX
+ cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
+#endif
+#ifdef JMP_BUF_SIZE
+ builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
+ JMP_BUF_SIZE);
+#endif
+ builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
+ STACK_POINTER_REGNUM);
+
+ /* For libgcov. */
+ builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
+ TARGET_VTABLE_USES_DESCRIPTORS);
+ }
+
/* 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);
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");
/* Show the availability of some target pragmas. */
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 == 4)
+ cpp_define (pfile, "__SSP_EXPLICIT__=4");
+ 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=200805");
+ if (flag_openacc)
+ cpp_define (pfile, "_OPENACC=201306");
- if (int128_integer_type_node != NULL_TREE)
- builtin_define_type_sizeof ("__SIZEOF_INT128__",
- int128_integer_type_node);
+ if (flag_openmp)
+ cpp_define (pfile, "_OPENMP=201307");
+
+ for (i = 0; i < NUM_INT_N_ENTS; i ++)
+ if (int_n_enabled_p[i])
+ {
+ char buf[15+20];
+ sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
+ builtin_define_type_sizeof (buf,
+ int_n_trees[i].signed_type);
+ }
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__",
size_t extra = 2; /* space for an = and a NUL */
if (is_str)
- extra += 2; /* space for two quote marks */
+ {
+ char *quoted_expansion = (char *) alloca (elen * 4 + 1);
+ const char *p;
+ char *q;
+ extra += 2; /* space for two quote marks */
+ for (p = expansion, q = quoted_expansion; *p; p++)
+ {
+ switch (*p)
+ {
+ case '\n':
+ *q++ = '\\';
+ *q++ = 'n';
+ break;
+
+ case '\t':
+ *q++ = '\\';
+ *q++ = 't';
+ break;
+
+ case '\\':
+ *q++ = '\\';
+ *q++ = '\\';
+ break;
+
+ case '"':
+ *q++ = '\\';
+ *q++ = '"';
+ break;
+
+ default:
+ if (ISPRINT ((unsigned char) *p))
+ *q++ = *p;
+ else
+ {
+ sprintf (q, "\\%03o", (unsigned char) *p);
+ q += 4;
+ }
+ }
+ }
+ *q = '\0';
+ expansion = quoted_expansion;
+ elen = q - expansion;
+ }
buf = (char *) alloca (mlen + elen + extra);
if (is_str)
/* Pass an object-like macro and an integer value to define it to. */
-static void
+void
builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
{
char *buf;
{
const char *hex_str;
cpp_macro *macro;
- enum machine_mode mode;
+ machine_mode mode;
int digits;
const char *fp_suffix;
};
static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
int unsigned_suffix;
int is_long;
+ int tp = TYPE_PRECISION (type);
if (type == long_long_integer_type_node
- || type == long_long_unsigned_type_node)
+ || type == long_long_unsigned_type_node
+ || tp > TYPE_PRECISION (long_integer_type_node))
is_long = 2;
else if (type == long_integer_type_node
- || type == long_unsigned_type_node)
+ || type == long_unsigned_type_node
+ || tp > TYPE_PRECISION (integer_type_node))
is_long = 1;
else if (type == integer_type_node
|| type == unsigned_type_node
builtin_define_type_minmax (NULL, macro, type);
}
+/* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
+ representation of that value. For example, a COUNT of 10 would
+ return "0x3ff". */
+
+static void
+print_bits_of_hex (char *buf, int bufsz, int count)
+{
+ gcc_assert (bufsz > 3);
+ *buf++ = '0';
+ *buf++ = 'x';
+ bufsz -= 2;
+
+ gcc_assert (count > 0);
+
+ switch (count % 4) {
+ case 0:
+ break;
+ case 1:
+ *buf++ = '1';
+ bufsz --;
+ count -= 1;
+ break;
+ case 2:
+ *buf++ = '3';
+ bufsz --;
+ count -= 2;
+ break;
+ case 3:
+ *buf++ = '7';
+ bufsz --;
+ count -= 3;
+ break;
+ }
+ while (count >= 4)
+ {
+ gcc_assert (bufsz > 1);
+ *buf++ = 'f';
+ bufsz --;
+ count -= 4;
+ }
+ gcc_assert (bufsz > 0);
+ *buf++ = 0;
+}
+
/* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
precision of the type. */
builtin_define_type_minmax (const char *min_macro, const char *max_macro,
tree type)
{
- static const char *const values[]
- = { "127", "255",
- "32767", "65535",
- "2147483647", "4294967295",
- "9223372036854775807", "18446744073709551615",
- "170141183460469231731687303715884105727",
- "340282366920938463463374607431768211455" };
-
- const char *value, *suffix;
+#define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
+ char value[PBOH_SZ];
+
+ const char *suffix;
char *buf;
- size_t idx;
+ int bits;
- /* Pre-rendering the values mean we don't have to futz with printing a
- multi-word decimal value. There are also a very limited number of
- precisions that we support, so it's really a waste of time. */
- switch (TYPE_PRECISION (type))
- {
- case 8: idx = 0; break;
- case 16: idx = 2; break;
- case 32: idx = 4; break;
- case 64: idx = 6; break;
- case 128: idx = 8; break;
- default: gcc_unreachable ();
- }
+ bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
+
+ print_bits_of_hex (value, PBOH_SZ, bits);
- value = values[idx + TYPE_UNSIGNED (type)];
suffix = type_suffix (type);
buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
projects / platform / upstream / gcc.git / blobdiff