X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fc-cppbuiltin.c;h=c6e5c6d34f8662c6e6962b92da19b6bf7de749e2;hb=6e8435a1039a5266c33343f12606821de0c68c54;hp=e0d6189200953c16e819ef3744d245c01e9ae19a;hpb=a3b9d369501884ed81bb84239df3727f47fb64e4;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/c-cppbuiltin.c b/gcc/c-cppbuiltin.c index e0d61892009..c6e5c6d34f8 100644 --- a/gcc/c-cppbuiltin.c +++ b/gcc/c-cppbuiltin.c @@ -53,11 +53,14 @@ static void builtin_define_with_value_n (const char *, const char *, 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_type_max (const char *, tree, int); static void builtin_define_type_precision (const char *, tree); -static void builtin_define_float_constants (const char *, const char *, +static void builtin_define_float_constants (const char *, + const char *, + const char *, tree); static void define__GNUC__ (void); @@ -68,9 +71,13 @@ builtin_define_type_precision (const char *name, tree type) builtin_define_with_int_value (name, TYPE_PRECISION (type)); } -/* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */ +/* 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, tree type) +builtin_define_float_constants (const char *name_prefix, + const char *fp_suffix, + const char *fp_cast, + tree type) { /* Used to convert radix-based values to base 10 values in several cases. @@ -89,6 +96,7 @@ builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, 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) @@ -208,13 +216,13 @@ builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, } } sprintf (name, "__%s_MAX__", name_prefix); - builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix); + 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) * fmt->log2_b); - builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix); + 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). */ @@ -223,9 +231,9 @@ builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, /* 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); + builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); /* For C++ std::numeric_limits::denorm_min. The minimum denormalized positive floating-point number, b**(emin-p). Zero for formats that @@ -235,7 +243,7 @@ builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, { sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b); builtin_define_with_hex_fp_value (name, type, decimal_dig, - buf, fp_suffix); + buf, fp_suffix, fp_cast); } else { @@ -243,6 +251,9 @@ builtin_define_float_constants (const char *name_prefix, const char *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::has_infinity. */ sprintf (name, "__%s_HAS_INFINITY__", name_prefix); builtin_define_with_int_value (name, @@ -256,6 +267,70 @@ builtin_define_float_constants (const char *name_prefix, const char *fp_suffix, 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) @@ -276,7 +351,7 @@ define__GNUC__ (void) builtin_define_with_value_n ("__GNUG__", q, v - q); gcc_assert (*v == '.' && ISDIGIT (v[1])); - + q = ++v; while (ISDIGIT (*v)) v++; @@ -328,7 +403,7 @@ c_cpp_builtins (cpp_reader *pfile) 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"); @@ -345,7 +420,7 @@ c_cpp_builtins (cpp_reader *pfile) if (flag_abi_version == 0) /* Use a very large value so that: - #if __GXX_ABI_VERSION >= + #if __GXX_ABI_VERSION >= will work whether the user explicitly says "-fabi-version=x" or "-fabi-version=0". Do not use INT_MAX because that will be @@ -357,7 +432,7 @@ c_cpp_builtins (cpp_reader *pfile) 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. */ @@ -382,9 +457,25 @@ c_cpp_builtins (cpp_reader *pfile) builtin_define_with_int_value ("__FLT_EVAL_METHOD__", TARGET_FLT_EVAL_METHOD); - builtin_define_float_constants ("FLT", "F", float_type_node); - builtin_define_float_constants ("DBL", "", double_type_node); - builtin_define_float_constants ("LDBL", "L", long_double_type_node); + /* And decfloat.h needs this. */ + builtin_define_with_int_value ("__DEC_EVAL_METHOD__", + TARGET_DEC_EVAL_METHOD); + + builtin_define_float_constants ("FLT", "F", "%s", float_type_node); + /* Cast the double precision constants when single precision constants are + specified. The correct result is computed by the compiler when using + macros that include a cast. This has the side-effect of making the value + unusable in const expressions. */ + if (flag_single_precision_constant) + builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); + else + builtin_define_float_constants ("DBL", "", "%s", double_type_node); + builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); + + /* For decfloat.h. */ + builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); + builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); + builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); /* For use in assembly language. */ builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); @@ -453,6 +544,9 @@ c_cpp_builtins (cpp_reader *pfile) else if (flag_stack_protect == 1) cpp_define (pfile, "__SSP__=1"); + if (flag_openmp) + cpp_define (pfile, "_OPENMP=200505"); + /* A straightforward target hook doesn't work, because of problems linking that hook's body when part of non-C front ends. */ # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) @@ -486,7 +580,7 @@ void 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; @@ -532,7 +626,7 @@ builtin_define_with_value (const char *macro, const char *expansion, int is_str) 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 @@ -550,7 +644,7 @@ builtin_define_with_value_n (const char *macro, const char *expansion, size_t el 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); @@ -568,7 +662,7 @@ builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 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); @@ -580,10 +674,12 @@ builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) static void builtin_define_with_hex_fp_value (const char *macro, tree type ATTRIBUTE_UNUSED, int digits, - const char *hex_str, const char *fp_suffix) + const char *hex_str, + const char *fp_suffix, + const char *fp_cast) { REAL_VALUE_TYPE real; - char dec_str[64], buf[256]; + char dec_str[64], buf1[256], buf2[256]; /* Hex values are really cool and convenient, except that they're not supported in strict ISO C90 mode. First, the "p-" sequence @@ -598,8 +694,13 @@ builtin_define_with_hex_fp_value (const char *macro, real_from_string (&real, hex_str); real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0); - sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix); - cpp_define (parse_in, buf); + /* Assemble the macro in the following fashion + macro = fp_cast [dec_str fp_suffix] */ + sprintf (buf1, "%s%s", dec_str, fp_suffix); + sprintf (buf2, fp_cast, buf1); + sprintf (buf1, "%s=%s", macro, buf2); + + cpp_define (parse_in, buf1); } /* Define MAX for TYPE based on the precision of the type. IS_LONG is @@ -638,7 +739,8 @@ builtin_define_type_max (const char *macro, tree type, int is_long) 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);