Subversion Repositories openrisc

/* Define builtin-in macros for the C family front ends.

   Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011

   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under

the terms of the GNU General Public License as published by the Free

Software Foundation; either version 3, or (at your option) any later

version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY

WARRANTY; without even the implied warranty of MERCHANTABILITY or

FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

for more details.

You should have received a copy of the GNU General Public License

along with GCC; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "coretypes.h"

#include "tm.h"

#include "tree.h"

#include "version.h"

#include "flags.h"

#include "c-common.h"

#include "c-pragma.h"

#include "output.h"

#include "debug.h"              /* For dwarf2out_do_cfi_asm.  */

#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"

#ifndef TARGET_OS_CPP_BUILTINS

# define TARGET_OS_CPP_BUILTINS()

#endif

#ifndef TARGET_OBJFMT_CPP_BUILTINS

# define TARGET_OBJFMT_CPP_BUILTINS()

#endif

#ifndef REGISTER_PREFIX

#define REGISTER_PREFIX ""

#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 *,

                                              const char *);

static void builtin_define_stdint_macros (void);

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 (enum 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

builtin_define_type_sizeof (const char *name, tree type)

{

  builtin_define_with_int_value (name,

                                 tree_low_cst (TYPE_SIZE_UNIT (type), 1));

}

/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,

   and FP_CAST. */

static void

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.

     In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at

     least 6 significant digits for correct results.  Using the fraction

     formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an

     intermediate; perhaps someone can find a better approximation, in the

     mean time, I suspect using doubles won't harm the bootstrap here.  */

  const double log10_2 = .30102999566398119521;

  double log10_b;

  const struct real_format *fmt;

  const struct real_format *ldfmt;

  char name[64], buf[128];

  int dig, min_10_exp, max_10_exp;

  int decimal_dig;

  int type_decimal_dig;

  fmt = REAL_MODE_FORMAT (TYPE_MODE (type));

  gcc_assert (fmt->b != 10);

  ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));

  gcc_assert (ldfmt->b != 10);

  /* The radix of the exponent representation.  */

  if (type == float_type_node)

    builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);

  log10_b = log10_2;

  /* The number of radix digits, p, in the floating-point significand.  */

  sprintf (name, "__%s_MANT_DIG__", name_prefix);

  builtin_define_with_int_value (name, fmt->p);

  /* The number of decimal digits, q, such that any floating-point number

     with q decimal digits can be rounded into a floating-point number with

     p radix b digits and back again without change to the q decimal digits,

        p log10 b                       if b is a power of 10

        floor((p - 1) log10 b)          otherwise

  */

  dig = (fmt->p - 1) * log10_b;

  sprintf (name, "__%s_DIG__", name_prefix);

  builtin_define_with_int_value (name, dig);

  /* The minimum negative int x such that b**(x-1) is a normalized float.  */

  sprintf (name, "__%s_MIN_EXP__", name_prefix);

  sprintf (buf, "(%d)", fmt->emin);

  builtin_define_with_value (name, buf, 0);

  /* The minimum negative int x such that 10**x is a normalized float,

          ceil (log10 (b ** (emin - 1)))

        = ceil (log10 (b) * (emin - 1))

     Recall that emin is negative, so the integer truncation calculates

     the ceiling, not the floor, in this case.  */

  min_10_exp = (fmt->emin - 1) * log10_b;

  sprintf (name, "__%s_MIN_10_EXP__", name_prefix);

  sprintf (buf, "(%d)", min_10_exp);

  builtin_define_with_value (name, buf, 0);

  /* The maximum int x such that b**(x-1) is a representable float.  */

  sprintf (name, "__%s_MAX_EXP__", name_prefix);

  builtin_define_with_int_value (name, fmt->emax);

  /* The maximum int x such that 10**x is in the range of representable

     finite floating-point numbers,

          floor (log10((1 - b**-p) * b**emax))

        = floor (log10(1 - b**-p) + log10(b**emax))

        = floor (log10(1 - b**-p) + log10(b)*emax)

     The safest thing to do here is to just compute this number.  But since

     we don't link cc1 with libm, we cannot.  We could implement log10 here

     a series expansion, but that seems too much effort because:

     Note that the first term, for all extant p, is a number exceedingly close

     to zero, but slightly negative.  Note that the second term is an integer

     scaling an irrational number, and that because of the floor we are only

     interested in its integral portion.

     In order for the first term to have any effect on the integral portion

     of the second term, the second term has to be exceedingly close to an

     integer itself (e.g. 123.000000000001 or something).  Getting a result

     that close to an integer requires that the irrational multiplicand have

     a long series of zeros in its expansion, which doesn't occur in the

     first 20 digits or so of log10(b).

     Hand-waving aside, crunching all of the sets of constants above by hand

     does not yield a case for which the first term is significant, which

     in the end is all that matters.  */

  max_10_exp = fmt->emax * log10_b;

  sprintf (name, "__%s_MAX_10_EXP__", name_prefix);

  builtin_define_with_int_value (name, max_10_exp);

  /* The number of decimal digits, n, such that any floating-point number

     can be rounded to n decimal digits and back again without change to

     the value.

        p * log10(b)                    if b is a power of 10

        ceil(1 + p * log10(b))          otherwise

     The only macro we care about is this number for the widest supported

     floating type, but we want this value for rendering constants below.  */

  {

    double d_decimal_dig

      = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;

    decimal_dig = d_decimal_dig;

    if (decimal_dig < d_decimal_dig)

      decimal_dig++;

  }

  /* Similar, for this type rather than long double.  */

  {

    double type_d_decimal_dig = 1 + fmt->p * log10_b;

    type_decimal_dig = type_d_decimal_dig;

    if (type_decimal_dig < type_d_decimal_dig)

      type_decimal_dig++;

  }

  if (type == long_double_type_node)

    builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);

  else

    {

      sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);

      builtin_define_with_int_value (name, type_decimal_dig);

    }

  /* Since, for the supported formats, B is always a power of 2, we

     construct the following numbers directly as a hexadecimal

     constants.  */

  get_max_float (fmt, buf, sizeof (buf));

  sprintf (name, "__%s_MAX__", name_prefix);

  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);

  /* The minimum normalized positive floating-point number,

     b**(emin-1).  */

  sprintf (name, "__%s_MIN__", name_prefix);

  sprintf (buf, "0x1p%d", fmt->emin - 1);

  builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);

  /* The difference between 1 and the least value greater than 1 that is

     representable in the given floating point type, b**(1-p).  */

  sprintf (name, "__%s_EPSILON__", name_prefix);

  if (fmt->pnan < fmt->p)

    /* This is an IBM extended double format, so 1.0 + any double is

       representable precisely.  */

      sprintf (buf, "0x1p%d", fmt->emin - fmt->p);

    else

      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.  */

  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 (name, "__%s_HAS_DENORM__", name_prefix);

  builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);

  /* For C++ std::numeric_limits<T>::has_infinity.  */

  sprintf (name, "__%s_HAS_INFINITY__", name_prefix);

  builtin_define_with_int_value (name,

                                 MODE_HAS_INFINITIES (TYPE_MODE (type)));

  /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a

     predicate to distinguish a target that has both quiet and

     signalling NaNs from a target that has only quiet NaNs or only

     signalling NaNs, so we assume that a target that has any kind of

     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. */

static void

builtin_define_decimal_float_constants (const char *name_prefix,

                                        const char *suffix,

                                        tree type)

{

  const struct real_format *fmt;

  char name[64], buf[128], *p;

  int digits;

  fmt = REAL_MODE_FORMAT (TYPE_MODE (type));

  /* The number of radix digits, p, in the significand.  */

  sprintf (name, "__%s_MANT_DIG__", name_prefix);

  builtin_define_with_int_value (name, fmt->p);

  /* The minimum negative int x such that b**(x-1) is a normalized float.  */

  sprintf (name, "__%s_MIN_EXP__", name_prefix);

  sprintf (buf, "(%d)", fmt->emin);

  builtin_define_with_value (name, buf, 0);

  /* The maximum int x such that b**(x-1) is a representable float.  */

  sprintf (name, "__%s_MAX_EXP__", name_prefix);

  builtin_define_with_int_value (name, fmt->emax);

  /* Compute the minimum representable value.  */

  sprintf (name, "__%s_MIN__", name_prefix);

  sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);

  builtin_define_with_value (name, buf, 0);

  /* Compute the maximum representable value.  */

  sprintf (name, "__%s_MAX__", name_prefix);

  p = buf;

  for (digits = fmt->p; digits; digits--)

    {

      *p++ = '9';

      if (digits == fmt->p)

        *p++ = '.';

    }

  *p = 0;

  /* fmt->p plus 1, to account for the decimal point and fmt->emax

     minus 1 because the digits are nines, not 1.0.  */

  sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);

  builtin_define_with_value (name, buf, 0);

  /* Compute epsilon (the difference between 1 and least value greater

     than 1 representable).  */

  sprintf (name, "__%s_EPSILON__", name_prefix);

  sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);

  builtin_define_with_value (name, buf, 0);

  /* Minimum subnormal positive decimal value.  */

  sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);

  p = buf;

  for (digits = fmt->p; digits > 1; digits--)

    {

      *p++ = '0';

      if (digits == fmt->p)

        *p++ = '.';

    }

  *p = 0;

  sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);

  builtin_define_with_value (name, buf, 0);

}

/* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX.  */

static void

builtin_define_fixed_point_constants (const char *name_prefix,

                                      const char *suffix,

                                      tree type)

{

  char name[64], buf[256], *new_buf;

  int i, mod;

  sprintf (name, "__%s_FBIT__", name_prefix);

  builtin_define_with_int_value (name, TYPE_FBIT (type));

  sprintf (name, "__%s_IBIT__", name_prefix);

  builtin_define_with_int_value (name, TYPE_IBIT (type));

  /* If there is no suffix, defines are for fixed-point modes.

     We just return.  */

  if (strcmp (suffix, "") == 0)

    return;

  if (TYPE_UNSIGNED (type))

    {

      sprintf (name, "__%s_MIN__", name_prefix);

      sprintf (buf, "0.0%s", suffix);

      builtin_define_with_value (name, buf, 0);

    }

  else

    {

      sprintf (name, "__%s_MIN__", name_prefix);

      if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))

        sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,

                 TYPE_IBIT (type) - 1, suffix);

      else

        sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);

      builtin_define_with_value (name, buf, 0);

    }

  sprintf (name, "__%s_MAX__", name_prefix);

  sprintf (buf, "0X");

  new_buf = buf + 2;

  mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;

  if (mod)

    sprintf (new_buf++, "%x", (1 << mod) - 1);

  for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)

    sprintf (new_buf++, "F");

  sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);

  builtin_define_with_value (name, buf, 0);

  sprintf (name, "__%s_EPSILON__", name_prefix);

  sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);

  builtin_define_with_value (name, buf, 0);

}

/* Define macros used by <stdint.h>.  */

static void

builtin_define_stdint_macros (void)

{

  builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);

  builtin_define_constants ("__INTMAX_C", intmax_type_node);

  builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);

  builtin_define_constants ("__UINTMAX_C", uintmax_type_node);

  if (sig_atomic_type_node)

    builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",

                                sig_atomic_type_node);

  if (int8_type_node)

    builtin_define_type_max ("__INT8_MAX__", int8_type_node);

  if (int16_type_node)

    builtin_define_type_max ("__INT16_MAX__", int16_type_node);

  if (int32_type_node)

    builtin_define_type_max ("__INT32_MAX__", int32_type_node);

  if (int64_type_node)

    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_uint32_type_node)

    builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);

  if (c_uint64_type_node)

    builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);

  if (int_least8_type_node)

    {

      builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);

      builtin_define_constants ("__INT8_C", int_least8_type_node);

    }

  if (int_least16_type_node)

    {

      builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);

      builtin_define_constants ("__INT16_C", int_least16_type_node);

    }

  if (int_least32_type_node)

    {

      builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);

      builtin_define_constants ("__INT32_C", int_least32_type_node);

    }

  if (int_least64_type_node)

    {

      builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);

      builtin_define_constants ("__INT64_C", int_least64_type_node);

    }

  if (uint_least8_type_node)

    {

      builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);

      builtin_define_constants ("__UINT8_C", uint_least8_type_node);

    }

  if (uint_least16_type_node)

    {

      builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);

      builtin_define_constants ("__UINT16_C", uint_least16_type_node);

    }

  if (uint_least32_type_node)

    {

      builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);

      builtin_define_constants ("__UINT32_C", uint_least32_type_node);

    }

  if (uint_least64_type_node)

    {

      builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);

      builtin_define_constants ("__UINT64_C", uint_least64_type_node);

    }

  if (int_fast8_type_node)

    builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);

  if (int_fast16_type_node)

    builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);

  if (int_fast32_type_node)

    builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);

  if (int_fast64_type_node)

    builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);

  if (uint_fast8_type_node)

    builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);

  if (uint_fast16_type_node)

    builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);

  if (uint_fast32_type_node)

    builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);

  if (uint_fast64_type_node)

    builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);

  if (intptr_type_node)

    builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);

  if (uintptr_type_node)

    builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);

}

/* Adjust the optimization macros when a #pragma GCC optimization is done to

   reflect the current level.  */

void

c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,

                                tree cur_tree)

{

  struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);

  struct cl_optimization *cur  = TREE_OPTIMIZATION (cur_tree);

  bool prev_fast_math;

  bool cur_fast_math;

  /* -undef turns off target-specific built-ins.  */

  if (flag_undef)

    return;

  /* Other target-independent built-ins determined by command-line

     options.  */

  if (!prev->x_optimize_size && cur->x_optimize_size)

    cpp_define (pfile, "__OPTIMIZE_SIZE__");

  else if (prev->x_optimize_size && !cur->x_optimize_size)

    cpp_undef (pfile, "__OPTIMIZE_SIZE__");

  if (!prev->x_optimize && cur->x_optimize)

    cpp_define (pfile, "__OPTIMIZE__");

  else if (prev->x_optimize && !cur->x_optimize)

    cpp_undef (pfile, "__OPTIMIZE__");

  prev_fast_math = fast_math_flags_struct_set_p (prev);

  cur_fast_math  = fast_math_flags_struct_set_p (cur);

  if (!prev_fast_math && cur_fast_math)

    cpp_define (pfile, "__FAST_MATH__");

  else if (prev_fast_math && !cur_fast_math)

    cpp_undef (pfile, "__FAST_MATH__");

  if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)

    cpp_define (pfile, "__SUPPORT_SNAN__");

  else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)

    cpp_undef (pfile, "__SUPPORT_SNAN__");

  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)

    {

      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_low_cst (TYPE_SIZE_UNIT (T), 1))

#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));