/* Define builtin-in macros for the C family front ends.
- Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+ Free Software Foundation, Inc.
This file is part of GCC.
static void builtin_define_stdint_macros (void);
static void builtin_define_type_max (const char *, tree, int);
static void builtin_define_type_precision (const char *, tree);
+static void builtin_define_type_sizeof (const char *, tree);
static void builtin_define_float_constants (const char *,
const char *,
const char *,
builtin_define_with_int_value (name, TYPE_PRECISION (type));
}
+/* 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
int decimal_dig;
fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
+ gcc_assert (fmt->b != 10);
/* The radix of the exponent representation. */
if (type == float_type_node)
/* This is an IBM extended double format, so 1.0 + any double is
representable precisely. */
sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
- else
+ else
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_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
}
+/* 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, 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. */
+ sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, 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 denormalized postive decimal value. */
+ sprintf (name, "__%s_DEN__", 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, suffix);
+ builtin_define_with_value (name, buf, 0);
+}
+
/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
static void
define__GNUC__ (void)
builtin_define_with_value_n ("__GNUG__", q, v - q);
gcc_assert (*v == '.' && ISDIGIT (v[1]));
-
+
q = ++v;
while (ISDIGIT (*v))
v++;
if (c_dialect_cxx ())
{
- if (flag_weak && SUPPORTS_ONE_ONLY)
+ 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_cpp0x)
+ cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
if (flag_abi_version == 0)
/* 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
"-fabi-version=0". Do not use INT_MAX because that will be
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
else
/* 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);
/* libgcc needs to know this. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
TARGET_FLT_EVAL_METHOD);
+ /* And decfloat.h needs this. */
+ builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
+ TARGET_DEC_EVAL_METHOD);
+
builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
/* Cast the double precision constants when single precision constants are
specified. The correct result is computed by the compiler when using
builtin_define_float_constants ("DBL", "", "%s", double_type_node);
builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
+ /* For decfloat.h. */
+ builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
+ builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
+ builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
+
/* For use in assembly language. */
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
/* Misc. */
builtin_define_with_value ("__VERSION__", version_string, 1);
+ if (flag_gnu89_inline)
+ cpp_define (pfile, "__GNUC_GNU_INLINE__");
+ else
+ cpp_define (pfile, "__GNUC_STDC_INLINE__");
+
/* Definitions for LP64 model. */
if (TYPE_PRECISION (long_integer_type_node) == 64
&& POINTER_SIZE == 64
builtin_define_with_int_value ("__pic__", flag_pic);
builtin_define_with_int_value ("__PIC__", flag_pic);
}
+ if (flag_pie)
+ {
+ builtin_define_with_int_value ("__pie__", flag_pie);
+ builtin_define_with_int_value ("__PIE__", flag_pie);
+ }
if (flag_iso)
cpp_define (pfile, "__STRICT_ANSI__");
else if (flag_stack_protect == 1)
cpp_define (pfile, "__SSP__=1");
+ if (flag_openmp)
+ cpp_define (pfile, "_OPENMP=200505");
+
+ builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
+ long_long_integer_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
+ builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
+ unsigned_ptrdiff_type_node);
+ /* ptr_type_node can't be used here since ptr_mode is only set when
+ toplev calls backend_init which is not done with -E switch. */
+ builtin_define_with_int_value ("__SIZEOF_POINTER__",
+ POINTER_SIZE / BITS_PER_UNIT);
+
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
builtin_define_std (const char *macro)
{
size_t len = strlen (macro);
- char *buff = alloca (len + 5);
+ char *buff = (char *) alloca (len + 5);
char *p = buff + 2;
char *q = p + len;
if (is_str)
extra += 2; /* space for two quote marks */
- buf = alloca (mlen + elen + extra);
+ buf = (char *) alloca (mlen + elen + extra);
if (is_str)
sprintf (buf, "%s=\"%s\"", macro, expansion);
else
size_t mlen = strlen (macro);
/* Space for an = and a NUL. */
- buf = alloca (mlen + elen + 2);
+ buf = (char *) alloca (mlen + elen + 2);
memcpy (buf, macro, mlen);
buf[mlen] = '=';
memcpy (buf + mlen + 1, expansion, elen);
size_t vlen = 18;
size_t extra = 2; /* space for = and NUL. */
- buf = alloca (mlen + vlen + extra);
+ buf = (char *) alloca (mlen + vlen + extra);
memcpy (buf, macro, mlen);
buf[mlen] = '=';
sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
value = values[idx + TYPE_UNSIGNED (type)];
suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
- buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
+ buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
+ + strlen (suffix) + 1);
sprintf (buf, "%s=%s%s", macro, value, suffix);
cpp_define (parse_in, buf);
OSDN Git Service
