/* Define builtin-in macros for the C family front ends.
|
/* Define builtin-in macros for the C family front ends.
|
Copyright (C) 2002, 2003, 2004, 2005, 2007
|
Copyright (C) 2002, 2003, 2004, 2005, 2007
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
This file is part of GCC.
|
This file is part of GCC.
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
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
|
the terms of the GNU General Public License as published by the Free
|
Software Foundation; either version 3, or (at your option) any later
|
Software Foundation; either version 3, or (at your option) any later
|
version.
|
version.
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
for more details.
|
for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with GCC; see the file COPYING3. If not see
|
along with GCC; see the file COPYING3. If not see
|
<http://www.gnu.org/licenses/>. */
|
<http://www.gnu.org/licenses/>. */
|
|
|
#include "config.h"
|
#include "config.h"
|
#include "system.h"
|
#include "system.h"
|
#include "coretypes.h"
|
#include "coretypes.h"
|
#include "tm.h"
|
#include "tm.h"
|
#include "tree.h"
|
#include "tree.h"
|
#include "version.h"
|
#include "version.h"
|
#include "flags.h"
|
#include "flags.h"
|
#include "real.h"
|
#include "real.h"
|
#include "c-common.h"
|
#include "c-common.h"
|
#include "c-pragma.h"
|
#include "c-pragma.h"
|
#include "output.h"
|
#include "output.h"
|
#include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
|
#include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
|
#include "toplev.h"
|
#include "toplev.h"
|
#include "tm_p.h" /* Target prototypes. */
|
#include "tm_p.h" /* Target prototypes. */
|
#include "target.h"
|
#include "target.h"
|
|
|
#ifndef TARGET_OS_CPP_BUILTINS
|
#ifndef TARGET_OS_CPP_BUILTINS
|
# define TARGET_OS_CPP_BUILTINS()
|
# define TARGET_OS_CPP_BUILTINS()
|
#endif
|
#endif
|
|
|
#ifndef TARGET_OBJFMT_CPP_BUILTINS
|
#ifndef TARGET_OBJFMT_CPP_BUILTINS
|
# define TARGET_OBJFMT_CPP_BUILTINS()
|
# define TARGET_OBJFMT_CPP_BUILTINS()
|
#endif
|
#endif
|
|
|
#ifndef REGISTER_PREFIX
|
#ifndef REGISTER_PREFIX
|
#define REGISTER_PREFIX ""
|
#define REGISTER_PREFIX ""
|
#endif
|
#endif
|
|
|
/* Non-static as some targets don't use it. */
|
/* Non-static as some targets don't use it. */
|
void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
|
void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
|
static void builtin_define_with_value_n (const char *, const char *,
|
static void builtin_define_with_value_n (const char *, const char *,
|
size_t);
|
size_t);
|
static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
|
static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
|
static void builtin_define_with_hex_fp_value (const char *, tree,
|
static void builtin_define_with_hex_fp_value (const char *, tree,
|
int, const char *,
|
int, const char *,
|
const char *,
|
const char *,
|
const char *);
|
const char *);
|
static void builtin_define_stdint_macros (void);
|
static void builtin_define_stdint_macros (void);
|
static void builtin_define_type_max (const char *, tree, int);
|
static void builtin_define_type_max (const char *, tree, int);
|
static void builtin_define_type_precision (const char *, tree);
|
static void builtin_define_type_precision (const char *, tree);
|
static void builtin_define_float_constants (const char *,
|
static void builtin_define_float_constants (const char *,
|
const char *,
|
const char *,
|
const char *,
|
const char *,
|
tree);
|
tree);
|
static void define__GNUC__ (void);
|
static void define__GNUC__ (void);
|
|
|
/* Define NAME with value TYPE precision. */
|
/* Define NAME with value TYPE precision. */
|
static void
|
static void
|
builtin_define_type_precision (const char *name, tree type)
|
builtin_define_type_precision (const char *name, tree type)
|
{
|
{
|
builtin_define_with_int_value (name, TYPE_PRECISION (type));
|
builtin_define_with_int_value (name, TYPE_PRECISION (type));
|
}
|
}
|
|
|
/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
|
/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
|
and FP_CAST. */
|
and FP_CAST. */
|
static void
|
static void
|
builtin_define_float_constants (const char *name_prefix,
|
builtin_define_float_constants (const char *name_prefix,
|
const char *fp_suffix,
|
const char *fp_suffix,
|
const char *fp_cast,
|
const char *fp_cast,
|
tree type)
|
tree type)
|
{
|
{
|
/* Used to convert radix-based values to base 10 values in several cases.
|
/* 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
|
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
|
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
|
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
|
intermediate; perhaps someone can find a better approximation, in the
|
mean time, I suspect using doubles won't harm the bootstrap here. */
|
mean time, I suspect using doubles won't harm the bootstrap here. */
|
|
|
const double log10_2 = .30102999566398119521;
|
const double log10_2 = .30102999566398119521;
|
double log10_b;
|
double log10_b;
|
const struct real_format *fmt;
|
const struct real_format *fmt;
|
|
|
char name[64], buf[128];
|
char name[64], buf[128];
|
int dig, min_10_exp, max_10_exp;
|
int dig, min_10_exp, max_10_exp;
|
int decimal_dig;
|
int decimal_dig;
|
|
|
fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
gcc_assert (fmt->b != 10);
|
gcc_assert (fmt->b != 10);
|
|
|
/* The radix of the exponent representation. */
|
/* The radix of the exponent representation. */
|
if (type == float_type_node)
|
if (type == float_type_node)
|
builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
|
builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
|
log10_b = log10_2 * fmt->log2_b;
|
log10_b = log10_2 * fmt->log2_b;
|
|
|
/* The number of radix digits, p, in the floating-point significand. */
|
/* The number of radix digits, p, in the floating-point significand. */
|
sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
builtin_define_with_int_value (name, fmt->p);
|
builtin_define_with_int_value (name, fmt->p);
|
|
|
/* The number of decimal digits, q, such that any floating-point number
|
/* 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
|
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 radix b digits and back again without change to the q decimal digits,
|
|
|
p log10 b if b is a power of 10
|
p log10 b if b is a power of 10
|
floor((p - 1) log10 b) otherwise
|
floor((p - 1) log10 b) otherwise
|
*/
|
*/
|
dig = (fmt->p - 1) * log10_b;
|
dig = (fmt->p - 1) * log10_b;
|
sprintf (name, "__%s_DIG__", name_prefix);
|
sprintf (name, "__%s_DIG__", name_prefix);
|
builtin_define_with_int_value (name, dig);
|
builtin_define_with_int_value (name, dig);
|
|
|
/* The minimum negative int x such that b**(x-1) is a normalized float. */
|
/* The minimum negative int x such that b**(x-1) is a normalized float. */
|
sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
sprintf (buf, "(%d)", fmt->emin);
|
sprintf (buf, "(%d)", fmt->emin);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* The minimum negative int x such that 10**x is a normalized float,
|
/* The minimum negative int x such that 10**x is a normalized float,
|
|
|
ceil (log10 (b ** (emin - 1)))
|
ceil (log10 (b ** (emin - 1)))
|
= ceil (log10 (b) * (emin - 1))
|
= ceil (log10 (b) * (emin - 1))
|
|
|
Recall that emin is negative, so the integer truncation calculates
|
Recall that emin is negative, so the integer truncation calculates
|
the ceiling, not the floor, in this case. */
|
the ceiling, not the floor, in this case. */
|
min_10_exp = (fmt->emin - 1) * log10_b;
|
min_10_exp = (fmt->emin - 1) * log10_b;
|
sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
|
sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
|
sprintf (buf, "(%d)", min_10_exp);
|
sprintf (buf, "(%d)", min_10_exp);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* The maximum int x such that b**(x-1) is a representable float. */
|
/* The maximum int x such that b**(x-1) is a representable float. */
|
sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
builtin_define_with_int_value (name, fmt->emax);
|
builtin_define_with_int_value (name, fmt->emax);
|
|
|
/* The maximum int x such that 10**x is in the range of representable
|
/* The maximum int x such that 10**x is in the range of representable
|
finite floating-point numbers,
|
finite floating-point numbers,
|
|
|
floor (log10((1 - b**-p) * b**emax))
|
floor (log10((1 - b**-p) * b**emax))
|
= floor (log10(1 - b**-p) + log10(b**emax))
|
= floor (log10(1 - b**-p) + log10(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
|
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
|
we don't link cc1 with libm, we cannot. We could implement log10 here
|
a series expansion, but that seems too much effort because:
|
a series expansion, but that seems too much effort because:
|
|
|
Note that the first term, for all extant p, is a number exceedingly close
|
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
|
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
|
scaling an irrational number, and that because of the floor we are only
|
interested in its integral portion.
|
interested in its integral portion.
|
|
|
In order for the first term to have any effect on the 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
|
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
|
integer itself (e.g. 123.000000000001 or something). Getting a result
|
that close to an integer requires that the irrational multiplicand have
|
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
|
a long series of zeros in its expansion, which doesn't occur in the
|
first 20 digits or so of log10(b).
|
first 20 digits or so of log10(b).
|
|
|
Hand-waving aside, crunching all of the sets of constants above by hand
|
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
|
does not yield a case for which the first term is significant, which
|
in the end is all that matters. */
|
in the end is all that matters. */
|
max_10_exp = fmt->emax * log10_b;
|
max_10_exp = fmt->emax * log10_b;
|
sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
|
sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
|
builtin_define_with_int_value (name, max_10_exp);
|
builtin_define_with_int_value (name, max_10_exp);
|
|
|
/* The number of decimal digits, n, such that any floating-point number
|
/* 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
|
can be rounded to n decimal digits and back again without change to
|
the value.
|
the value.
|
|
|
p * log10(b) if b is a power of 10
|
p * log10(b) if b is a power of 10
|
ceil(1 + p * log10(b)) otherwise
|
ceil(1 + p * log10(b)) otherwise
|
|
|
The only macro we care about is this number for the widest supported
|
The only macro we care about is this number for the widest supported
|
floating type, but we want this value for rendering constants below. */
|
floating type, but we want this value for rendering constants below. */
|
{
|
{
|
double d_decimal_dig = 1 + fmt->p * log10_b;
|
double d_decimal_dig = 1 + fmt->p * log10_b;
|
decimal_dig = d_decimal_dig;
|
decimal_dig = d_decimal_dig;
|
if (decimal_dig < d_decimal_dig)
|
if (decimal_dig < d_decimal_dig)
|
decimal_dig++;
|
decimal_dig++;
|
}
|
}
|
if (type == long_double_type_node)
|
if (type == long_double_type_node)
|
builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
|
builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
|
|
|
/* Since, for the supported formats, B is always a power of 2, we
|
/* Since, for the supported formats, B is always a power of 2, we
|
construct the following numbers directly as a hexadecimal
|
construct the following numbers directly as a hexadecimal
|
constants. */
|
constants. */
|
|
|
/* The maximum representable finite floating-point number,
|
/* The maximum representable finite floating-point number,
|
(1 - b**-p) * b**emax */
|
(1 - b**-p) * b**emax */
|
{
|
{
|
int i, n;
|
int i, n;
|
char *p;
|
char *p;
|
|
|
strcpy (buf, "0x0.");
|
strcpy (buf, "0x0.");
|
n = fmt->p * fmt->log2_b;
|
n = fmt->p * fmt->log2_b;
|
for (i = 0, p = buf + 4; i + 3 < n; i += 4)
|
for (i = 0, p = buf + 4; i + 3 < n; i += 4)
|
*p++ = 'f';
|
*p++ = 'f';
|
if (i < n)
|
if (i < n)
|
*p++ = "08ce"[n - i];
|
*p++ = "08ce"[n - i];
|
sprintf (p, "p%d", fmt->emax * fmt->log2_b);
|
sprintf (p, "p%d", fmt->emax * fmt->log2_b);
|
if (fmt->pnan < fmt->p)
|
if (fmt->pnan < fmt->p)
|
{
|
{
|
/* This is an IBM extended double format made up of two IEEE
|
/* This is an IBM extended double format made up of two IEEE
|
doubles. The value of the long double is the sum of the
|
doubles. The value of the long double is the sum of the
|
values of the two parts. The most significant part is
|
values of the two parts. The most significant part is
|
required to be the value of the long double rounded to the
|
required to be the value of the long double rounded to the
|
nearest double. Rounding means we need a slightly smaller
|
nearest double. Rounding means we need a slightly smaller
|
value for LDBL_MAX. */
|
value for LDBL_MAX. */
|
buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
|
buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
|
}
|
}
|
}
|
}
|
sprintf (name, "__%s_MAX__", name_prefix);
|
sprintf (name, "__%s_MAX__", name_prefix);
|
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
|
|
/* The minimum normalized positive floating-point number,
|
/* The minimum normalized positive floating-point number,
|
b**(emin-1). */
|
b**(emin-1). */
|
sprintf (name, "__%s_MIN__", name_prefix);
|
sprintf (name, "__%s_MIN__", name_prefix);
|
sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
|
sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
|
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
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
|
/* The difference between 1 and the least value greater than 1 that is
|
representable in the given floating point type, b**(1-p). */
|
representable in the given floating point type, b**(1-p). */
|
sprintf (name, "__%s_EPSILON__", name_prefix);
|
sprintf (name, "__%s_EPSILON__", name_prefix);
|
if (fmt->pnan < fmt->p)
|
if (fmt->pnan < fmt->p)
|
/* This is an IBM extended double format, so 1.0 + any double is
|
/* This is an IBM extended double format, so 1.0 + any double is
|
representable precisely. */
|
representable precisely. */
|
sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
|
sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
|
else
|
else
|
sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
|
sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
|
builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
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
|
/* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
|
positive floating-point number, b**(emin-p). Zero for formats that
|
positive floating-point number, b**(emin-p). Zero for formats that
|
don't support denormals. */
|
don't support denormals. */
|
sprintf (name, "__%s_DENORM_MIN__", name_prefix);
|
sprintf (name, "__%s_DENORM_MIN__", name_prefix);
|
if (fmt->has_denorm)
|
if (fmt->has_denorm)
|
{
|
{
|
sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
|
sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
|
builtin_define_with_hex_fp_value (name, type, decimal_dig,
|
builtin_define_with_hex_fp_value (name, type, decimal_dig,
|
buf, fp_suffix, fp_cast);
|
buf, fp_suffix, fp_cast);
|
}
|
}
|
else
|
else
|
{
|
{
|
sprintf (buf, "0.0%s", fp_suffix);
|
sprintf (buf, "0.0%s", fp_suffix);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
}
|
}
|
|
|
sprintf (name, "__%s_HAS_DENORM__", name_prefix);
|
sprintf (name, "__%s_HAS_DENORM__", name_prefix);
|
builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
|
builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
|
|
|
/* For C++ std::numeric_limits<T>::has_infinity. */
|
/* For C++ std::numeric_limits<T>::has_infinity. */
|
sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
|
sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
|
builtin_define_with_int_value (name,
|
builtin_define_with_int_value (name,
|
MODE_HAS_INFINITIES (TYPE_MODE (type)));
|
MODE_HAS_INFINITIES (TYPE_MODE (type)));
|
/* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
|
/* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
|
predicate to distinguish a target that has both quiet and
|
predicate to distinguish a target that has both quiet and
|
signalling NaNs from a target that has only quiet NaNs or only
|
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
|
signalling NaNs, so we assume that a target that has any kind of
|
NaN has quiet NaNs. */
|
NaN has quiet NaNs. */
|
sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
|
sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
|
builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
|
builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
|
}
|
}
|
|
|
/* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
|
/* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
|
static void
|
static void
|
builtin_define_decimal_float_constants (const char *name_prefix,
|
builtin_define_decimal_float_constants (const char *name_prefix,
|
const char *suffix,
|
const char *suffix,
|
tree type)
|
tree type)
|
{
|
{
|
const struct real_format *fmt;
|
const struct real_format *fmt;
|
char name[64], buf[128], *p;
|
char name[64], buf[128], *p;
|
int digits;
|
int digits;
|
|
|
fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
|
|
/* The number of radix digits, p, in the significand. */
|
/* The number of radix digits, p, in the significand. */
|
sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
builtin_define_with_int_value (name, fmt->p);
|
builtin_define_with_int_value (name, fmt->p);
|
|
|
/* The minimum negative int x such that b**(x-1) is a normalized float. */
|
/* The minimum negative int x such that b**(x-1) is a normalized float. */
|
sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
sprintf (buf, "(%d)", fmt->emin);
|
sprintf (buf, "(%d)", fmt->emin);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* The maximum int x such that b**(x-1) is a representable float. */
|
/* The maximum int x such that b**(x-1) is a representable float. */
|
sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
builtin_define_with_int_value (name, fmt->emax);
|
builtin_define_with_int_value (name, fmt->emax);
|
|
|
/* Compute the minimum representable value. */
|
/* Compute the minimum representable value. */
|
sprintf (name, "__%s_MIN__", name_prefix);
|
sprintf (name, "__%s_MIN__", name_prefix);
|
sprintf (buf, "1E%d%s", fmt->emin, suffix);
|
sprintf (buf, "1E%d%s", fmt->emin, suffix);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* Compute the maximum representable value. */
|
/* Compute the maximum representable value. */
|
sprintf (name, "__%s_MAX__", name_prefix);
|
sprintf (name, "__%s_MAX__", name_prefix);
|
p = buf;
|
p = buf;
|
for (digits = fmt->p; digits; digits--)
|
for (digits = fmt->p; digits; digits--)
|
{
|
{
|
*p++ = '9';
|
*p++ = '9';
|
if (digits == fmt->p)
|
if (digits == fmt->p)
|
*p++ = '.';
|
*p++ = '.';
|
}
|
}
|
*p = 0;
|
*p = 0;
|
/* fmt->p plus 1, to account for the decimal point. */
|
/* fmt->p plus 1, to account for the decimal point. */
|
sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix);
|
sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* Compute epsilon (the difference between 1 and least value greater
|
/* Compute epsilon (the difference between 1 and least value greater
|
than 1 representable). */
|
than 1 representable). */
|
sprintf (name, "__%s_EPSILON__", name_prefix);
|
sprintf (name, "__%s_EPSILON__", name_prefix);
|
sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
|
sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
|
|
/* Minimum denormalized postive decimal value. */
|
/* Minimum denormalized postive decimal value. */
|
sprintf (name, "__%s_DEN__", name_prefix);
|
sprintf (name, "__%s_DEN__", name_prefix);
|
p = buf;
|
p = buf;
|
for (digits = fmt->p; digits > 1; digits--)
|
for (digits = fmt->p; digits > 1; digits--)
|
{
|
{
|
*p++ = '0';
|
*p++ = '0';
|
if (digits == fmt->p)
|
if (digits == fmt->p)
|
*p++ = '.';
|
*p++ = '.';
|
}
|
}
|
*p = 0;
|
*p = 0;
|
sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
|
sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
|
builtin_define_with_value (name, buf, 0);
|
builtin_define_with_value (name, buf, 0);
|
}
|
}
|
|
|
/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
|
/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
|
static void
|
static void
|
define__GNUC__ (void)
|
define__GNUC__ (void)
|
{
|
{
|
/* The format of the version string, enforced below, is
|
/* The format of the version string, enforced below, is
|
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
|
([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
|
const char *q, *v = version_string;
|
const char *q, *v = version_string;
|
|
|
while (*v && !ISDIGIT (*v))
|
while (*v && !ISDIGIT (*v))
|
v++;
|
v++;
|
gcc_assert (*v && (v <= version_string || v[-1] == '-'));
|
gcc_assert (*v && (v <= version_string || v[-1] == '-'));
|
|
|
q = v;
|
q = v;
|
while (ISDIGIT (*v))
|
while (ISDIGIT (*v))
|
v++;
|
v++;
|
builtin_define_with_value_n ("__GNUC__", q, v - q);
|
builtin_define_with_value_n ("__GNUC__", q, v - q);
|
if (c_dialect_cxx ())
|
if (c_dialect_cxx ())
|
builtin_define_with_value_n ("__GNUG__", q, v - q);
|
builtin_define_with_value_n ("__GNUG__", q, v - q);
|
|
|
gcc_assert (*v == '.' && ISDIGIT (v[1]));
|
gcc_assert (*v == '.' && ISDIGIT (v[1]));
|
|
|
q = ++v;
|
q = ++v;
|
while (ISDIGIT (*v))
|
while (ISDIGIT (*v))
|
v++;
|
v++;
|
builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
|
builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
|
|
|
if (*v == '.')
|
if (*v == '.')
|
{
|
{
|
gcc_assert (ISDIGIT (v[1]));
|
gcc_assert (ISDIGIT (v[1]));
|
q = ++v;
|
q = ++v;
|
while (ISDIGIT (*v))
|
while (ISDIGIT (*v))
|
v++;
|
v++;
|
builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
|
builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
|
}
|
}
|
else
|
else
|
builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
|
builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
|
|
|
gcc_assert (!*v || *v == ' ' || *v == '-');
|
gcc_assert (!*v || *v == ' ' || *v == '-');
|
}
|
}
|
|
|
/* Define macros used by <stdint.h>. Currently only defines limits
|
/* Define macros used by <stdint.h>. Currently only defines limits
|
for intmax_t, used by the testsuite. */
|
for intmax_t, used by the testsuite. */
|
static void
|
static void
|
builtin_define_stdint_macros (void)
|
builtin_define_stdint_macros (void)
|
{
|
{
|
int intmax_long;
|
int intmax_long;
|
if (intmax_type_node == long_long_integer_type_node)
|
if (intmax_type_node == long_long_integer_type_node)
|
intmax_long = 2;
|
intmax_long = 2;
|
else if (intmax_type_node == long_integer_type_node)
|
else if (intmax_type_node == long_integer_type_node)
|
intmax_long = 1;
|
intmax_long = 1;
|
else if (intmax_type_node == integer_type_node)
|
else if (intmax_type_node == integer_type_node)
|
intmax_long = 0;
|
intmax_long = 0;
|
else
|
else
|
gcc_unreachable ();
|
gcc_unreachable ();
|
builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
|
builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
|
}
|
}
|
|
|
/* Hook that registers front end and target-specific built-ins. */
|
/* Hook that registers front end and target-specific built-ins. */
|
void
|
void
|
c_cpp_builtins (cpp_reader *pfile)
|
c_cpp_builtins (cpp_reader *pfile)
|
{
|
{
|
/* -undef turns off target-specific built-ins. */
|
/* -undef turns off target-specific built-ins. */
|
if (flag_undef)
|
if (flag_undef)
|
return;
|
return;
|
|
|
define__GNUC__ ();
|
define__GNUC__ ();
|
|
|
/* For stddef.h. They require macros defined in c-common.c. */
|
/* For stddef.h. They require macros defined in c-common.c. */
|
c_stddef_cpp_builtins ();
|
c_stddef_cpp_builtins ();
|
|
|
if (c_dialect_cxx ())
|
if (c_dialect_cxx ())
|
{
|
{
|
if (flag_weak && SUPPORTS_ONE_ONLY)
|
if (flag_weak && SUPPORTS_ONE_ONLY)
|
cpp_define (pfile, "__GXX_WEAK__=1");
|
cpp_define (pfile, "__GXX_WEAK__=1");
|
else
|
else
|
cpp_define (pfile, "__GXX_WEAK__=0");
|
cpp_define (pfile, "__GXX_WEAK__=0");
|
if (warn_deprecated)
|
if (warn_deprecated)
|
cpp_define (pfile, "__DEPRECATED");
|
cpp_define (pfile, "__DEPRECATED");
|
}
|
}
|
/* Note that we define this for C as well, so that we know if
|
/* Note that we define this for C as well, so that we know if
|
__attribute__((cleanup)) will interface with EH. */
|
__attribute__((cleanup)) will interface with EH. */
|
if (flag_exceptions)
|
if (flag_exceptions)
|
cpp_define (pfile, "__EXCEPTIONS");
|
cpp_define (pfile, "__EXCEPTIONS");
|
|
|
/* Represents the C++ ABI version, always defined so it can be used while
|
/* Represents the C++ ABI version, always defined so it can be used while
|
preprocessing C and assembler. */
|
preprocessing C and assembler. */
|
if (flag_abi_version == 0)
|
if (flag_abi_version == 0)
|
/* Use a very large value so that:
|
/* Use a very large value so that:
|
|
|
#if __GXX_ABI_VERSION >= <value for version X>
|
#if __GXX_ABI_VERSION >= <value for version X>
|
|
|
will work whether the user explicitly says "-fabi-version=x" or
|
will work whether the user explicitly says "-fabi-version=x" or
|
"-fabi-version=0". Do not use INT_MAX because that will be
|
"-fabi-version=0". Do not use INT_MAX because that will be
|
different from system to system. */
|
different from system to system. */
|
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
|
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
|
else if (flag_abi_version == 1)
|
else if (flag_abi_version == 1)
|
/* Due to a historical accident, this version had the value
|
/* Due to a historical accident, this version had the value
|
"102". */
|
"102". */
|
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
|
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
|
else
|
else
|
/* Newer versions have values 1002, 1003, .... */
|
/* Newer versions have values 1002, 1003, .... */
|
builtin_define_with_int_value ("__GXX_ABI_VERSION",
|
builtin_define_with_int_value ("__GXX_ABI_VERSION",
|
1000 + flag_abi_version);
|
1000 + flag_abi_version);
|
|
|
/* libgcc needs to know this. */
|
/* libgcc needs to know this. */
|
if (USING_SJLJ_EXCEPTIONS)
|
if (USING_SJLJ_EXCEPTIONS)
|
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
|
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
|
|
|
/* limits.h needs to know these. */
|
/* limits.h needs to know these. */
|
builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
|
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 ("__SHRT_MAX__", short_integer_type_node, 0);
|
builtin_define_type_max ("__INT_MAX__", 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_MAX__", long_integer_type_node, 1);
|
builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
|
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_max ("__WCHAR_MAX__", wchar_type_node, 0);
|
|
|
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
|
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
|
|
|
/* stdint.h (eventually) and the testsuite need to know these. */
|
/* stdint.h (eventually) and the testsuite need to know these. */
|
builtin_define_stdint_macros ();
|
builtin_define_stdint_macros ();
|
|
|
/* float.h needs to know these. */
|
/* float.h needs to know these. */
|
|
|
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
|
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
|
TARGET_FLT_EVAL_METHOD);
|
TARGET_FLT_EVAL_METHOD);
|
|
|
/* And decfloat.h needs this. */
|
/* And decfloat.h needs this. */
|
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
|
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
|
TARGET_DEC_EVAL_METHOD);
|
TARGET_DEC_EVAL_METHOD);
|
|
|
builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
|
builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
|
/* Cast the double precision constants when single precision constants are
|
/* Cast the double precision constants when single precision constants are
|
specified. The correct result is computed by the compiler when using
|
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
|
macros that include a cast. This has the side-effect of making the value
|
unusable in const expressions. */
|
unusable in const expressions. */
|
if (flag_single_precision_constant)
|
if (flag_single_precision_constant)
|
builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
|
builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
|
else
|
else
|
builtin_define_float_constants ("DBL", "", "%s", double_type_node);
|
builtin_define_float_constants ("DBL", "", "%s", double_type_node);
|
builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
|
builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
|
|
|
/* For decfloat.h. */
|
/* For decfloat.h. */
|
builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
|
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 ("DEC64", "DD", dfloat64_type_node);
|
builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
|
builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
|
|
|
/* For use in assembly language. */
|
/* For use in assembly language. */
|
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
|
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
|
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
|
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
|
|
|
/* Misc. */
|
/* Misc. */
|
builtin_define_with_value ("__VERSION__", version_string, 1);
|
builtin_define_with_value ("__VERSION__", version_string, 1);
|
|
|
cpp_define (pfile, "__GNUC_GNU_INLINE__");
|
cpp_define (pfile, "__GNUC_GNU_INLINE__");
|
|
|
/* Definitions for LP64 model. */
|
/* Definitions for LP64 model. */
|
if (TYPE_PRECISION (long_integer_type_node) == 64
|
if (TYPE_PRECISION (long_integer_type_node) == 64
|
&& POINTER_SIZE == 64
|
&& POINTER_SIZE == 64
|
&& TYPE_PRECISION (integer_type_node) == 32)
|
&& TYPE_PRECISION (integer_type_node) == 32)
|
{
|
{
|
cpp_define (pfile, "_LP64");
|
cpp_define (pfile, "_LP64");
|
cpp_define (pfile, "__LP64__");
|
cpp_define (pfile, "__LP64__");
|
}
|
}
|
|
|
/* Other target-independent built-ins determined by command-line
|
/* Other target-independent built-ins determined by command-line
|
options. */
|
options. */
|
if (optimize_size)
|
if (optimize_size)
|
cpp_define (pfile, "__OPTIMIZE_SIZE__");
|
cpp_define (pfile, "__OPTIMIZE_SIZE__");
|
if (optimize)
|
if (optimize)
|
cpp_define (pfile, "__OPTIMIZE__");
|
cpp_define (pfile, "__OPTIMIZE__");
|
|
|
if (fast_math_flags_set_p ())
|
if (fast_math_flags_set_p ())
|
cpp_define (pfile, "__FAST_MATH__");
|
cpp_define (pfile, "__FAST_MATH__");
|
if (flag_really_no_inline)
|
if (flag_really_no_inline)
|
cpp_define (pfile, "__NO_INLINE__");
|
cpp_define (pfile, "__NO_INLINE__");
|
if (flag_signaling_nans)
|
if (flag_signaling_nans)
|
cpp_define (pfile, "__SUPPORT_SNAN__");
|
cpp_define (pfile, "__SUPPORT_SNAN__");
|
if (flag_finite_math_only)
|
if (flag_finite_math_only)
|
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
|
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
|
else
|
else
|
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
|
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
|
if (flag_pic)
|
if (flag_pic)
|
{
|
{
|
builtin_define_with_int_value ("__pic__", flag_pic);
|
builtin_define_with_int_value ("__pic__", flag_pic);
|
builtin_define_with_int_value ("__PIC__", flag_pic);
|
builtin_define_with_int_value ("__PIC__", flag_pic);
|
}
|
}
|
|
|
if (flag_iso)
|
if (flag_iso)
|
cpp_define (pfile, "__STRICT_ANSI__");
|
cpp_define (pfile, "__STRICT_ANSI__");
|
|
|
if (!flag_signed_char)
|
if (!flag_signed_char)
|
cpp_define (pfile, "__CHAR_UNSIGNED__");
|
cpp_define (pfile, "__CHAR_UNSIGNED__");
|
|
|
if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
|
if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
|
cpp_define (pfile, "__WCHAR_UNSIGNED__");
|
cpp_define (pfile, "__WCHAR_UNSIGNED__");
|
|
|
/* Make the choice of ObjC runtime visible to source code. */
|
/* Make the choice of ObjC runtime visible to source code. */
|
if (c_dialect_objc () && flag_next_runtime)
|
if (c_dialect_objc () && flag_next_runtime)
|
cpp_define (pfile, "__NEXT_RUNTIME__");
|
cpp_define (pfile, "__NEXT_RUNTIME__");
|
|
|
/* Show the availability of some target pragmas. */
|
/* Show the availability of some target pragmas. */
|
if (flag_mudflap || targetm.handle_pragma_redefine_extname)
|
if (flag_mudflap || targetm.handle_pragma_redefine_extname)
|
cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
|
cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
|
|
|
if (targetm.handle_pragma_extern_prefix)
|
if (targetm.handle_pragma_extern_prefix)
|
cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
|
cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
|
|
|
/* Make the choice of the stack protector runtime visible to source code.
|
/* Make the choice of the stack protector runtime visible to source code.
|
The macro names and values here were chosen for compatibility with an
|
The macro names and values here were chosen for compatibility with an
|
earlier implementation, i.e. ProPolice. */
|
earlier implementation, i.e. ProPolice. */
|
if (flag_stack_protect == 2)
|
if (flag_stack_protect == 2)
|
cpp_define (pfile, "__SSP_ALL__=2");
|
cpp_define (pfile, "__SSP_ALL__=2");
|
else if (flag_stack_protect == 1)
|
else if (flag_stack_protect == 1)
|
cpp_define (pfile, "__SSP__=1");
|
cpp_define (pfile, "__SSP__=1");
|
|
|
if (flag_openmp)
|
if (flag_openmp)
|
cpp_define (pfile, "_OPENMP=200505");
|
cpp_define (pfile, "_OPENMP=200505");
|
|
|
/* A straightforward target hook doesn't work, because of problems
|
/* A straightforward target hook doesn't work, because of problems
|
linking that hook's body when part of non-C front ends. */
|
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_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
|
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
|
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
|
# define builtin_define(TXT) cpp_define (pfile, TXT)
|
# define builtin_define(TXT) cpp_define (pfile, TXT)
|
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
|
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
|
TARGET_CPU_CPP_BUILTINS ();
|
TARGET_CPU_CPP_BUILTINS ();
|
TARGET_OS_CPP_BUILTINS ();
|
TARGET_OS_CPP_BUILTINS ();
|
TARGET_OBJFMT_CPP_BUILTINS ();
|
TARGET_OBJFMT_CPP_BUILTINS ();
|
|
|
/* Support the __declspec keyword by turning them into attributes.
|
/* Support the __declspec keyword by turning them into attributes.
|
Note that the current way we do this may result in a collision
|
Note that the current way we do this may result in a collision
|
with predefined attributes later on. This can be solved by using
|
with predefined attributes later on. This can be solved by using
|
one attribute, say __declspec__, and passing args to it. The
|
one attribute, say __declspec__, and passing args to it. The
|
problem with that approach is that args are not accumulated: each
|
problem with that approach is that args are not accumulated: each
|
new appearance would clobber any existing args. */
|
new appearance would clobber any existing args. */
|
if (TARGET_DECLSPEC)
|
if (TARGET_DECLSPEC)
|
builtin_define ("__declspec(x)=__attribute__((x))");
|
builtin_define ("__declspec(x)=__attribute__((x))");
|
}
|
}
|
|
|
/* Pass an object-like macro. If it doesn't lie in the user's
|
/* Pass an object-like macro. If it doesn't lie in the user's
|
namespace, defines it unconditionally. Otherwise define a version
|
namespace, defines it unconditionally. Otherwise define a version
|
with two leading underscores, and another version with two leading
|
with two leading underscores, and another version with two leading
|
and trailing underscores, and define the original only if an ISO
|
and trailing underscores, and define the original only if an ISO
|
standard was not nominated.
|
standard was not nominated.
|
|
|
e.g. passing "unix" defines "__unix", "__unix__" and possibly
|
e.g. passing "unix" defines "__unix", "__unix__" and possibly
|
"unix". Passing "_mips" defines "__mips", "__mips__" and possibly
|
"unix". Passing "_mips" defines "__mips", "__mips__" and possibly
|
"_mips". */
|
"_mips". */
|
void
|
void
|
builtin_define_std (const char *macro)
|
builtin_define_std (const char *macro)
|
{
|
{
|
size_t len = strlen (macro);
|
size_t len = strlen (macro);
|
char *buff = (char *) alloca (len + 5);
|
char *buff = (char *) alloca (len + 5);
|
char *p = buff + 2;
|
char *p = buff + 2;
|
char *q = p + len;
|
char *q = p + len;
|
|
|
/* prepend __ (or maybe just _) if in user's namespace. */
|
/* prepend __ (or maybe just _) if in user's namespace. */
|
memcpy (p, macro, len + 1);
|
memcpy (p, macro, len + 1);
|
if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
|
if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
|
{
|
{
|
if (*p != '_')
|
if (*p != '_')
|
*--p = '_';
|
*--p = '_';
|
if (p[1] != '_')
|
if (p[1] != '_')
|
*--p = '_';
|
*--p = '_';
|
}
|
}
|
cpp_define (parse_in, p);
|
cpp_define (parse_in, p);
|
|
|
/* If it was in user's namespace... */
|
/* If it was in user's namespace... */
|
if (p != buff + 2)
|
if (p != buff + 2)
|
{
|
{
|
/* Define the macro with leading and following __. */
|
/* Define the macro with leading and following __. */
|
if (q[-1] != '_')
|
if (q[-1] != '_')
|
*q++ = '_';
|
*q++ = '_';
|
if (q[-2] != '_')
|
if (q[-2] != '_')
|
*q++ = '_';
|
*q++ = '_';
|
*q = '\0';
|
*q = '\0';
|
cpp_define (parse_in, p);
|
cpp_define (parse_in, p);
|
|
|
/* Finally, define the original macro if permitted. */
|
/* Finally, define the original macro if permitted. */
|
if (!flag_iso)
|
if (!flag_iso)
|
cpp_define (parse_in, macro);
|
cpp_define (parse_in, macro);
|
}
|
}
|
}
|
}
|
|
|
/* Pass an object-like macro and a value to define it to. The third
|
/* Pass an object-like macro and a value to define it to. The third
|
parameter says whether or not to turn the value into a string
|
parameter says whether or not to turn the value into a string
|
constant. */
|
constant. */
|
void
|
void
|
builtin_define_with_value (const char *macro, const char *expansion, int is_str)
|
builtin_define_with_value (const char *macro, const char *expansion, int is_str)
|
{
|
{
|
char *buf;
|
char *buf;
|
size_t mlen = strlen (macro);
|
size_t mlen = strlen (macro);
|
size_t elen = strlen (expansion);
|
size_t elen = strlen (expansion);
|
size_t extra = 2; /* space for an = and a NUL */
|
size_t extra = 2; /* space for an = and a NUL */
|
|
|
if (is_str)
|
if (is_str)
|
extra += 2; /* space for two quote marks */
|
extra += 2; /* space for two quote marks */
|
|
|
buf = (char *) alloca (mlen + elen + extra);
|
buf = (char *) alloca (mlen + elen + extra);
|
if (is_str)
|
if (is_str)
|
sprintf (buf, "%s=\"%s\"", macro, expansion);
|
sprintf (buf, "%s=\"%s\"", macro, expansion);
|
else
|
else
|
sprintf (buf, "%s=%s", macro, expansion);
|
sprintf (buf, "%s=%s", macro, expansion);
|
|
|
cpp_define (parse_in, buf);
|
cpp_define (parse_in, buf);
|
}
|
}
|
|
|
/* Pass an object-like macro and a value to define it to. The third
|
/* Pass an object-like macro and a value to define it to. The third
|
parameter is the length of the expansion. */
|
parameter is the length of the expansion. */
|
static void
|
static void
|
builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
|
builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
|
{
|
{
|
char *buf;
|
char *buf;
|
size_t mlen = strlen (macro);
|
size_t mlen = strlen (macro);
|
|
|
/* Space for an = and a NUL. */
|
/* Space for an = and a NUL. */
|
buf = (char *) alloca (mlen + elen + 2);
|
buf = (char *) alloca (mlen + elen + 2);
|
memcpy (buf, macro, mlen);
|
memcpy (buf, macro, mlen);
|
buf[mlen] = '=';
|
buf[mlen] = '=';
|
memcpy (buf + mlen + 1, expansion, elen);
|
memcpy (buf + mlen + 1, expansion, elen);
|
buf[mlen + elen + 1] = '\0';
|
buf[mlen + elen + 1] = '\0';
|
|
|
cpp_define (parse_in, buf);
|
cpp_define (parse_in, buf);
|
}
|
}
|
|
|
/* Pass an object-like macro and an integer value to define it to. */
|
/* Pass an object-like macro and an integer value to define it to. */
|
static void
|
static void
|
builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
|
builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
|
{
|
{
|
char *buf;
|
char *buf;
|
size_t mlen = strlen (macro);
|
size_t mlen = strlen (macro);
|
size_t vlen = 18;
|
size_t vlen = 18;
|
size_t extra = 2; /* space for = and NUL. */
|
size_t extra = 2; /* space for = and NUL. */
|
|
|
buf = (char *) alloca (mlen + vlen + extra);
|
buf = (char *) alloca (mlen + vlen + extra);
|
memcpy (buf, macro, mlen);
|
memcpy (buf, macro, mlen);
|
buf[mlen] = '=';
|
buf[mlen] = '=';
|
sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
|
sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
|
|
|
cpp_define (parse_in, buf);
|
cpp_define (parse_in, buf);
|
}
|
}
|
|
|
/* Pass an object-like macro a hexadecimal floating-point value. */
|
/* Pass an object-like macro a hexadecimal floating-point value. */
|
static void
|
static void
|
builtin_define_with_hex_fp_value (const char *macro,
|
builtin_define_with_hex_fp_value (const char *macro,
|
tree type ATTRIBUTE_UNUSED, int digits,
|
tree type ATTRIBUTE_UNUSED, int digits,
|
const char *hex_str,
|
const char *hex_str,
|
const char *fp_suffix,
|
const char *fp_suffix,
|
const char *fp_cast)
|
const char *fp_cast)
|
{
|
{
|
REAL_VALUE_TYPE real;
|
REAL_VALUE_TYPE real;
|
char dec_str[64], buf1[256], buf2[256];
|
char dec_str[64], buf1[256], buf2[256];
|
|
|
/* Hex values are really cool and convenient, except that they're
|
/* Hex values are really cool and convenient, except that they're
|
not supported in strict ISO C90 mode. First, the "p-" sequence
|
not supported in strict ISO C90 mode. First, the "p-" sequence
|
is not valid as part of a preprocessor number. Second, we get a
|
is not valid as part of a preprocessor number. Second, we get a
|
pedwarn from the preprocessor, which has no context, so we can't
|
pedwarn from the preprocessor, which has no context, so we can't
|
suppress the warning with __extension__.
|
suppress the warning with __extension__.
|
|
|
So instead what we do is construct the number in hex (because
|
So instead what we do is construct the number in hex (because
|
it's easy to get the exact correct value), parse it as a real,
|
it's easy to get the exact correct value), parse it as a real,
|
then print it back out as decimal. */
|
then print it back out as decimal. */
|
|
|
real_from_string (&real, hex_str);
|
real_from_string (&real, hex_str);
|
real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
|
real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
|
|
|
/* Assemble the macro in the following fashion
|
/* Assemble the macro in the following fashion
|
macro = fp_cast [dec_str fp_suffix] */
|
macro = fp_cast [dec_str fp_suffix] */
|
sprintf (buf1, "%s%s", dec_str, fp_suffix);
|
sprintf (buf1, "%s%s", dec_str, fp_suffix);
|
sprintf (buf2, fp_cast, buf1);
|
sprintf (buf2, fp_cast, buf1);
|
sprintf (buf1, "%s=%s", macro, buf2);
|
sprintf (buf1, "%s=%s", macro, buf2);
|
|
|
cpp_define (parse_in, buf1);
|
cpp_define (parse_in, buf1);
|
}
|
}
|
|
|
/* Define MAX for TYPE based on the precision of the type. IS_LONG is
|
/* Define MAX for TYPE based on the precision of the type. IS_LONG is
|
1 for type "long" and 2 for "long long". We have to handle
|
1 for type "long" and 2 for "long long". We have to handle
|
unsigned types, since wchar_t might be unsigned. */
|
unsigned types, since wchar_t might be unsigned. */
|
|
|
static void
|
static void
|
builtin_define_type_max (const char *macro, tree type, int is_long)
|
builtin_define_type_max (const char *macro, tree type, int is_long)
|
{
|
{
|
static const char *const values[]
|
static const char *const values[]
|
= { "127", "255",
|
= { "127", "255",
|
"32767", "65535",
|
"32767", "65535",
|
"2147483647", "4294967295",
|
"2147483647", "4294967295",
|
"9223372036854775807", "18446744073709551615",
|
"9223372036854775807", "18446744073709551615",
|
"170141183460469231731687303715884105727",
|
"170141183460469231731687303715884105727",
|
"340282366920938463463374607431768211455" };
|
"340282366920938463463374607431768211455" };
|
static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
|
static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
|
|
|
const char *value, *suffix;
|
const char *value, *suffix;
|
char *buf;
|
char *buf;
|
size_t idx;
|
size_t idx;
|
|
|
/* Pre-rendering the values mean we don't have to futz with printing a
|
/* 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
|
multi-word decimal value. There are also a very limited number of
|
precisions that we support, so it's really a waste of time. */
|
precisions that we support, so it's really a waste of time. */
|
switch (TYPE_PRECISION (type))
|
switch (TYPE_PRECISION (type))
|
{
|
{
|
case 8: idx = 0; break;
|
case 8: idx = 0; break;
|
case 16: idx = 2; break;
|
case 16: idx = 2; break;
|
case 32: idx = 4; break;
|
case 32: idx = 4; break;
|
case 64: idx = 6; break;
|
case 64: idx = 6; break;
|
case 128: idx = 8; break;
|
case 128: idx = 8; break;
|
default: gcc_unreachable ();
|
default: gcc_unreachable ();
|
}
|
}
|
|
|
value = values[idx + TYPE_UNSIGNED (type)];
|
value = values[idx + TYPE_UNSIGNED (type)];
|
suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
|
suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
|
|
|
buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
|
buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
|
+ strlen (suffix) + 1);
|
+ strlen (suffix) + 1);
|
sprintf (buf, "%s=%s%s", macro, value, suffix);
|
sprintf (buf, "%s=%s%s", macro, value, suffix);
|
|
|
cpp_define (parse_in, buf);
|
cpp_define (parse_in, buf);
|
}
|
}
|
|
|
