Mercurial > hg > CbC > CbC_gcc
annotate gcc/c-cppbuiltin.c @ 63:b7f97abdc517 gcc-4.6-20100522
update gcc from gcc-4.5.0 to gcc-4.6
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 24 May 2010 12:47:05 +0900 |
| parents | 77e2b8dfacca |
| children |
| rev | line source |
|---|---|
| 0 | 1 /* Define builtin-in macros for the C family front ends. |
| 2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 | |
| 3 Free Software Foundation, Inc. | |
| 4 | |
| 5 This file is part of GCC. | |
| 6 | |
| 7 GCC is free software; you can redistribute it and/or modify it under | |
| 8 the terms of the GNU General Public License as published by the Free | |
| 9 Software Foundation; either version 3, or (at your option) any later | |
| 10 version. | |
| 11 | |
| 12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 13 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 15 for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU General Public License | |
| 18 along with GCC; see the file COPYING3. If not see | |
| 19 <http://www.gnu.org/licenses/>. */ | |
| 20 | |
| 21 #include "config.h" | |
| 22 #include "system.h" | |
| 23 #include "coretypes.h" | |
| 24 #include "tm.h" | |
| 25 #include "tree.h" | |
| 26 #include "version.h" | |
| 27 #include "flags.h" | |
| 28 #include "c-common.h" | |
| 29 #include "c-pragma.h" | |
| 30 #include "output.h" | |
| 31 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */ | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */ |
| 0 | 33 #include "toplev.h" |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
34 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */ |
| 0 | 35 #include "target.h" |
| 36 | |
| 37 #ifndef TARGET_OS_CPP_BUILTINS | |
| 38 # define TARGET_OS_CPP_BUILTINS() | |
| 39 #endif | |
| 40 | |
| 41 #ifndef TARGET_OBJFMT_CPP_BUILTINS | |
| 42 # define TARGET_OBJFMT_CPP_BUILTINS() | |
| 43 #endif | |
| 44 | |
| 45 #ifndef REGISTER_PREFIX | |
| 46 #define REGISTER_PREFIX "" | |
| 47 #endif | |
| 48 | |
| 49 /* Non-static as some targets don't use it. */ | |
| 50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED; | |
| 51 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT); | |
| 52 static void builtin_define_with_hex_fp_value (const char *, tree, | |
| 53 int, const char *, | |
| 54 const char *, | |
| 55 const char *); | |
| 56 static void builtin_define_stdint_macros (void); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
57 static void builtin_define_constants (const char *, tree); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
58 static void builtin_define_type_max (const char *, tree); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
59 static void builtin_define_type_minmax (const char *, const char *, tree); |
| 0 | 60 static void builtin_define_type_precision (const char *, tree); |
| 61 static void builtin_define_type_sizeof (const char *, tree); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
62 static void builtin_define_float_constants (const char *, |
| 0 | 63 const char *, |
| 64 const char *, | |
| 65 tree); | |
| 66 static void define__GNUC__ (void); | |
| 67 | |
| 68 /* Define NAME with value TYPE precision. */ | |
| 69 static void | |
| 70 builtin_define_type_precision (const char *name, tree type) | |
| 71 { | |
| 72 builtin_define_with_int_value (name, TYPE_PRECISION (type)); | |
| 73 } | |
| 74 | |
| 75 /* Define NAME with value TYPE size_unit. */ | |
| 76 static void | |
| 77 builtin_define_type_sizeof (const char *name, tree type) | |
| 78 { | |
| 79 builtin_define_with_int_value (name, | |
| 80 tree_low_cst (TYPE_SIZE_UNIT (type), 1)); | |
| 81 } | |
| 82 | |
| 83 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX, | |
| 84 and FP_CAST. */ | |
| 85 static void | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
86 builtin_define_float_constants (const char *name_prefix, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
87 const char *fp_suffix, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
88 const char *fp_cast, |
| 0 | 89 tree type) |
| 90 { | |
| 91 /* Used to convert radix-based values to base 10 values in several cases. | |
| 92 | |
| 93 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at | |
| 94 least 6 significant digits for correct results. Using the fraction | |
| 95 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an | |
| 96 intermediate; perhaps someone can find a better approximation, in the | |
| 97 mean time, I suspect using doubles won't harm the bootstrap here. */ | |
| 98 | |
| 99 const double log10_2 = .30102999566398119521; | |
| 100 double log10_b; | |
| 101 const struct real_format *fmt; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
102 const struct real_format *ldfmt; |
| 0 | 103 |
| 104 char name[64], buf[128]; | |
| 105 int dig, min_10_exp, max_10_exp; | |
| 106 int decimal_dig; | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
107 int type_decimal_dig; |
| 0 | 108 |
| 109 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); | |
| 110 gcc_assert (fmt->b != 10); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
111 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
112 gcc_assert (ldfmt->b != 10); |
| 0 | 113 |
| 114 /* The radix of the exponent representation. */ | |
| 115 if (type == float_type_node) | |
| 116 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b); | |
| 117 log10_b = log10_2; | |
| 118 | |
| 119 /* The number of radix digits, p, in the floating-point significand. */ | |
| 120 sprintf (name, "__%s_MANT_DIG__", name_prefix); | |
| 121 builtin_define_with_int_value (name, fmt->p); | |
| 122 | |
| 123 /* The number of decimal digits, q, such that any floating-point number | |
| 124 with q decimal digits can be rounded into a floating-point number with | |
| 125 p radix b digits and back again without change to the q decimal digits, | |
| 126 | |
| 127 p log10 b if b is a power of 10 | |
| 128 floor((p - 1) log10 b) otherwise | |
| 129 */ | |
| 130 dig = (fmt->p - 1) * log10_b; | |
| 131 sprintf (name, "__%s_DIG__", name_prefix); | |
| 132 builtin_define_with_int_value (name, dig); | |
| 133 | |
| 134 /* The minimum negative int x such that b**(x-1) is a normalized float. */ | |
| 135 sprintf (name, "__%s_MIN_EXP__", name_prefix); | |
| 136 sprintf (buf, "(%d)", fmt->emin); | |
| 137 builtin_define_with_value (name, buf, 0); | |
| 138 | |
| 139 /* The minimum negative int x such that 10**x is a normalized float, | |
| 140 | |
| 141 ceil (log10 (b ** (emin - 1))) | |
| 142 = ceil (log10 (b) * (emin - 1)) | |
| 143 | |
| 144 Recall that emin is negative, so the integer truncation calculates | |
| 145 the ceiling, not the floor, in this case. */ | |
| 146 min_10_exp = (fmt->emin - 1) * log10_b; | |
| 147 sprintf (name, "__%s_MIN_10_EXP__", name_prefix); | |
| 148 sprintf (buf, "(%d)", min_10_exp); | |
| 149 builtin_define_with_value (name, buf, 0); | |
| 150 | |
| 151 /* The maximum int x such that b**(x-1) is a representable float. */ | |
| 152 sprintf (name, "__%s_MAX_EXP__", name_prefix); | |
| 153 builtin_define_with_int_value (name, fmt->emax); | |
| 154 | |
| 155 /* The maximum int x such that 10**x is in the range of representable | |
| 156 finite floating-point numbers, | |
| 157 | |
| 158 floor (log10((1 - b**-p) * b**emax)) | |
| 159 = floor (log10(1 - b**-p) + log10(b**emax)) | |
| 160 = floor (log10(1 - b**-p) + log10(b)*emax) | |
| 161 | |
| 162 The safest thing to do here is to just compute this number. But since | |
| 163 we don't link cc1 with libm, we cannot. We could implement log10 here | |
| 164 a series expansion, but that seems too much effort because: | |
| 165 | |
| 166 Note that the first term, for all extant p, is a number exceedingly close | |
| 167 to zero, but slightly negative. Note that the second term is an integer | |
| 168 scaling an irrational number, and that because of the floor we are only | |
| 169 interested in its integral portion. | |
| 170 | |
| 171 In order for the first term to have any effect on the integral portion | |
| 172 of the second term, the second term has to be exceedingly close to an | |
| 173 integer itself (e.g. 123.000000000001 or something). Getting a result | |
| 174 that close to an integer requires that the irrational multiplicand have | |
| 175 a long series of zeros in its expansion, which doesn't occur in the | |
| 176 first 20 digits or so of log10(b). | |
| 177 | |
| 178 Hand-waving aside, crunching all of the sets of constants above by hand | |
| 179 does not yield a case for which the first term is significant, which | |
| 180 in the end is all that matters. */ | |
| 181 max_10_exp = fmt->emax * log10_b; | |
| 182 sprintf (name, "__%s_MAX_10_EXP__", name_prefix); | |
| 183 builtin_define_with_int_value (name, max_10_exp); | |
| 184 | |
| 185 /* The number of decimal digits, n, such that any floating-point number | |
| 186 can be rounded to n decimal digits and back again without change to | |
| 187 the value. | |
| 188 | |
| 189 p * log10(b) if b is a power of 10 | |
| 190 ceil(1 + p * log10(b)) otherwise | |
| 191 | |
| 192 The only macro we care about is this number for the widest supported | |
| 193 floating type, but we want this value for rendering constants below. */ | |
| 194 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
195 double d_decimal_dig |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
196 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b; |
| 0 | 197 decimal_dig = d_decimal_dig; |
| 198 if (decimal_dig < d_decimal_dig) | |
| 199 decimal_dig++; | |
| 200 } | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
201 /* Similar, for this type rather than long double. */ |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
202 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
203 double type_d_decimal_dig = 1 + fmt->p * log10_b; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
204 type_decimal_dig = type_d_decimal_dig; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
205 if (type_decimal_dig < type_d_decimal_dig) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
206 type_decimal_dig++; |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
207 } |
| 0 | 208 if (type == long_double_type_node) |
| 209 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig); | |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
210 else |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
211 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
212 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
213 builtin_define_with_int_value (name, type_decimal_dig); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
214 } |
| 0 | 215 |
| 216 /* Since, for the supported formats, B is always a power of 2, we | |
| 217 construct the following numbers directly as a hexadecimal | |
| 218 constants. */ | |
| 219 get_max_float (fmt, buf, sizeof (buf)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
220 |
| 0 | 221 sprintf (name, "__%s_MAX__", name_prefix); |
| 222 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); | |
| 223 | |
| 224 /* The minimum normalized positive floating-point number, | |
| 225 b**(emin-1). */ | |
| 226 sprintf (name, "__%s_MIN__", name_prefix); | |
| 227 sprintf (buf, "0x1p%d", fmt->emin - 1); | |
| 228 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); | |
| 229 | |
| 230 /* The difference between 1 and the least value greater than 1 that is | |
| 231 representable in the given floating point type, b**(1-p). */ | |
| 232 sprintf (name, "__%s_EPSILON__", name_prefix); | |
| 233 if (fmt->pnan < fmt->p) | |
| 234 /* This is an IBM extended double format, so 1.0 + any double is | |
| 235 representable precisely. */ | |
| 236 sprintf (buf, "0x1p%d", fmt->emin - fmt->p); | |
| 237 else | |
| 238 sprintf (buf, "0x1p%d", 1 - fmt->p); | |
| 239 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); | |
| 240 | |
| 241 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized | |
| 242 positive floating-point number, b**(emin-p). Zero for formats that | |
| 243 don't support denormals. */ | |
| 244 sprintf (name, "__%s_DENORM_MIN__", name_prefix); | |
| 245 if (fmt->has_denorm) | |
| 246 { | |
| 247 sprintf (buf, "0x1p%d", fmt->emin - fmt->p); | |
| 248 builtin_define_with_hex_fp_value (name, type, decimal_dig, | |
| 249 buf, fp_suffix, fp_cast); | |
| 250 } | |
| 251 else | |
| 252 { | |
| 253 sprintf (buf, "0.0%s", fp_suffix); | |
| 254 builtin_define_with_value (name, buf, 0); | |
| 255 } | |
| 256 | |
| 257 sprintf (name, "__%s_HAS_DENORM__", name_prefix); | |
| 258 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0); | |
| 259 | |
| 260 /* For C++ std::numeric_limits<T>::has_infinity. */ | |
| 261 sprintf (name, "__%s_HAS_INFINITY__", name_prefix); | |
| 262 builtin_define_with_int_value (name, | |
| 263 MODE_HAS_INFINITIES (TYPE_MODE (type))); | |
| 264 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a | |
| 265 predicate to distinguish a target that has both quiet and | |
| 266 signalling NaNs from a target that has only quiet NaNs or only | |
| 267 signalling NaNs, so we assume that a target that has any kind of | |
| 268 NaN has quiet NaNs. */ | |
| 269 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix); | |
| 270 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type))); | |
| 271 } | |
| 272 | |
| 273 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */ | |
| 274 static void | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
275 builtin_define_decimal_float_constants (const char *name_prefix, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
276 const char *suffix, |
| 0 | 277 tree type) |
| 278 { | |
| 279 const struct real_format *fmt; | |
| 280 char name[64], buf[128], *p; | |
| 281 int digits; | |
| 282 | |
| 283 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); | |
| 284 | |
| 285 /* The number of radix digits, p, in the significand. */ | |
| 286 sprintf (name, "__%s_MANT_DIG__", name_prefix); | |
| 287 builtin_define_with_int_value (name, fmt->p); | |
| 288 | |
| 289 /* The minimum negative int x such that b**(x-1) is a normalized float. */ | |
| 290 sprintf (name, "__%s_MIN_EXP__", name_prefix); | |
| 291 sprintf (buf, "(%d)", fmt->emin); | |
| 292 builtin_define_with_value (name, buf, 0); | |
| 293 | |
| 294 /* The maximum int x such that b**(x-1) is a representable float. */ | |
| 295 sprintf (name, "__%s_MAX_EXP__", name_prefix); | |
| 296 builtin_define_with_int_value (name, fmt->emax); | |
| 297 | |
| 298 /* Compute the minimum representable value. */ | |
| 299 sprintf (name, "__%s_MIN__", name_prefix); | |
| 300 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
301 builtin_define_with_value (name, buf, 0); |
| 0 | 302 |
| 303 /* Compute the maximum representable value. */ | |
| 304 sprintf (name, "__%s_MAX__", name_prefix); | |
| 305 p = buf; | |
| 306 for (digits = fmt->p; digits; digits--) | |
| 307 { | |
| 308 *p++ = '9'; | |
| 309 if (digits == fmt->p) | |
| 310 *p++ = '.'; | |
| 311 } | |
| 312 *p = 0; | |
| 313 /* fmt->p plus 1, to account for the decimal point and fmt->emax | |
| 314 minus 1 because the digits are nines, not 1.0. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
315 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix); |
| 0 | 316 builtin_define_with_value (name, buf, 0); |
| 317 | |
| 318 /* Compute epsilon (the difference between 1 and least value greater | |
| 319 than 1 representable). */ | |
| 320 sprintf (name, "__%s_EPSILON__", name_prefix); | |
| 321 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix); | |
| 322 builtin_define_with_value (name, buf, 0); | |
| 323 | |
| 324 /* Minimum subnormal positive decimal value. */ | |
| 325 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix); | |
| 326 p = buf; | |
| 327 for (digits = fmt->p; digits > 1; digits--) | |
| 328 { | |
| 329 *p++ = '0'; | |
| 330 if (digits == fmt->p) | |
| 331 *p++ = '.'; | |
| 332 } | |
| 333 *p = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
334 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix); |
| 0 | 335 builtin_define_with_value (name, buf, 0); |
| 336 } | |
| 337 | |
| 338 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */ | |
| 339 | |
| 340 static void | |
| 341 builtin_define_fixed_point_constants (const char *name_prefix, | |
| 342 const char *suffix, | |
| 343 tree type) | |
| 344 { | |
| 345 char name[64], buf[256], *new_buf; | |
| 346 int i, mod; | |
| 347 | |
| 348 sprintf (name, "__%s_FBIT__", name_prefix); | |
| 349 builtin_define_with_int_value (name, TYPE_FBIT (type)); | |
| 350 | |
| 351 sprintf (name, "__%s_IBIT__", name_prefix); | |
| 352 builtin_define_with_int_value (name, TYPE_IBIT (type)); | |
| 353 | |
| 354 /* If there is no suffix, defines are for fixed-point modes. | |
| 355 We just return. */ | |
| 356 if (strcmp (suffix, "") == 0) | |
| 357 return; | |
| 358 | |
| 359 if (TYPE_UNSIGNED (type)) | |
| 360 { | |
| 361 sprintf (name, "__%s_MIN__", name_prefix); | |
| 362 sprintf (buf, "0.0%s", suffix); | |
| 363 builtin_define_with_value (name, buf, 0); | |
| 364 } | |
| 365 else | |
| 366 { | |
| 367 sprintf (name, "__%s_MIN__", name_prefix); | |
| 368 if (ALL_ACCUM_MODE_P (TYPE_MODE (type))) | |
| 369 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix, | |
| 370 TYPE_IBIT (type) - 1, suffix); | |
| 371 else | |
| 372 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix); | |
| 373 builtin_define_with_value (name, buf, 0); | |
| 374 } | |
| 375 | |
| 376 sprintf (name, "__%s_MAX__", name_prefix); | |
| 377 sprintf (buf, "0X"); | |
| 378 new_buf = buf + 2; | |
| 379 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4; | |
| 380 if (mod) | |
| 381 sprintf (new_buf++, "%x", (1 << mod) - 1); | |
| 382 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++) | |
| 383 sprintf (new_buf++, "F"); | |
| 384 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix); | |
| 385 builtin_define_with_value (name, buf, 0); | |
| 386 | |
| 387 sprintf (name, "__%s_EPSILON__", name_prefix); | |
| 388 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix); | |
| 389 builtin_define_with_value (name, buf, 0); | |
| 390 } | |
| 391 | |
| 392 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */ | |
| 393 static void | |
| 394 define__GNUC__ (void) | |
| 395 { | |
| 396 int major, minor, patchlevel; | |
| 397 | |
| 398 if (sscanf (BASEVER, "%d.%d.%d", &major, &minor, &patchlevel) != 3) | |
| 399 { | |
| 400 sscanf (BASEVER, "%d.%d", &major, &minor); | |
| 401 patchlevel = 0; | |
| 402 } | |
| 403 cpp_define_formatted (parse_in, "__GNUC__=%d", major); | |
| 404 cpp_define_formatted (parse_in, "__GNUC_MINOR__=%d", minor); | |
| 405 cpp_define_formatted (parse_in, "__GNUC_PATCHLEVEL__=%d", patchlevel); | |
| 406 | |
| 407 if (c_dialect_cxx ()) | |
| 408 cpp_define_formatted (parse_in, "__GNUG__=%d", major); | |
| 409 } | |
| 410 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
411 /* Define macros used by <stdint.h>. */ |
| 0 | 412 static void |
| 413 builtin_define_stdint_macros (void) | |
| 414 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
415 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
416 builtin_define_constants ("__INTMAX_C", intmax_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
417 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
418 builtin_define_constants ("__UINTMAX_C", uintmax_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
419 if (sig_atomic_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
420 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
421 sig_atomic_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
422 if (int8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
423 builtin_define_type_max ("__INT8_MAX__", int8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
424 if (int16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
425 builtin_define_type_max ("__INT16_MAX__", int16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
426 if (int32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
427 builtin_define_type_max ("__INT32_MAX__", int32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
428 if (int64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
429 builtin_define_type_max ("__INT64_MAX__", int64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
430 if (uint8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
431 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
432 if (uint16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
433 builtin_define_type_max ("__UINT16_MAX__", uint16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
434 if (c_uint32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
435 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
436 if (c_uint64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
437 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
438 if (int_least8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
439 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
440 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
441 builtin_define_constants ("__INT8_C", int_least8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
442 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
443 if (int_least16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
444 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
445 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
446 builtin_define_constants ("__INT16_C", int_least16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
447 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
448 if (int_least32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
449 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
450 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
451 builtin_define_constants ("__INT32_C", int_least32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
452 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
453 if (int_least64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
454 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
455 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
456 builtin_define_constants ("__INT64_C", int_least64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
457 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
458 if (uint_least8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
459 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
460 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
461 builtin_define_constants ("__UINT8_C", uint_least8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
462 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
463 if (uint_least16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
464 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
465 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
466 builtin_define_constants ("__UINT16_C", uint_least16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
467 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
468 if (uint_least32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
469 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
470 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
471 builtin_define_constants ("__UINT32_C", uint_least32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
472 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
473 if (uint_least64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
474 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
475 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
476 builtin_define_constants ("__UINT64_C", uint_least64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
477 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
478 if (int_fast8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
479 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
480 if (int_fast16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
481 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
482 if (int_fast32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
483 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
484 if (int_fast64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
485 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
486 if (uint_fast8_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
487 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
488 if (uint_fast16_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
489 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
490 if (uint_fast32_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
491 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
492 if (uint_fast64_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
493 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
494 if (intptr_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
495 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
496 if (uintptr_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
497 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node); |
| 0 | 498 } |
| 499 | |
| 500 /* Adjust the optimization macros when a #pragma GCC optimization is done to | |
| 501 reflect the current level. */ | |
| 502 void | |
| 503 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree, | |
| 504 tree cur_tree) | |
| 505 { | |
| 506 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree); | |
| 507 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree); | |
| 508 bool prev_fast_math; | |
| 509 bool cur_fast_math; | |
| 510 | |
| 511 /* -undef turns off target-specific built-ins. */ | |
| 512 if (flag_undef) | |
| 513 return; | |
| 514 | |
| 515 /* Other target-independent built-ins determined by command-line | |
| 516 options. */ | |
| 517 if (!prev->optimize_size && cur->optimize_size) | |
| 518 cpp_define (pfile, "__OPTIMIZE_SIZE__"); | |
| 519 else if (prev->optimize_size && !cur->optimize_size) | |
| 520 cpp_undef (pfile, "__OPTIMIZE_SIZE__"); | |
| 521 | |
| 522 if (!prev->optimize && cur->optimize) | |
| 523 cpp_define (pfile, "__OPTIMIZE__"); | |
| 524 else if (prev->optimize && !cur->optimize) | |
| 525 cpp_undef (pfile, "__OPTIMIZE__"); | |
| 526 | |
| 527 prev_fast_math = fast_math_flags_struct_set_p (prev); | |
| 528 cur_fast_math = fast_math_flags_struct_set_p (cur); | |
| 529 if (!prev_fast_math && cur_fast_math) | |
| 530 cpp_define (pfile, "__FAST_MATH__"); | |
| 531 else if (prev_fast_math && !cur_fast_math) | |
| 532 cpp_undef (pfile, "__FAST_MATH__"); | |
| 533 | |
| 534 if (!prev->flag_signaling_nans && cur->flag_signaling_nans) | |
| 535 cpp_define (pfile, "__SUPPORT_SNAN__"); | |
| 536 else if (prev->flag_signaling_nans && !cur->flag_signaling_nans) | |
| 537 cpp_undef (pfile, "__SUPPORT_SNAN__"); | |
| 538 | |
| 539 if (!prev->flag_finite_math_only && cur->flag_finite_math_only) | |
| 540 { | |
| 541 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); | |
| 542 cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); | |
| 543 } | |
| 544 else if (!prev->flag_finite_math_only && cur->flag_finite_math_only) | |
| 545 { | |
| 546 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); | |
| 547 cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); | |
| 548 } | |
| 549 } | |
| 550 | |
| 551 | |
| 552 /* Hook that registers front end and target-specific built-ins. */ | |
| 553 void | |
| 554 c_cpp_builtins (cpp_reader *pfile) | |
| 555 { | |
| 556 /* -undef turns off target-specific built-ins. */ | |
| 557 if (flag_undef) | |
| 558 return; | |
| 559 | |
| 560 define__GNUC__ (); | |
| 561 | |
| 562 /* For stddef.h. They require macros defined in c-common.c. */ | |
| 563 c_stddef_cpp_builtins (); | |
| 564 | |
| 565 if (c_dialect_cxx ()) | |
| 566 { | |
| 567 if (flag_weak && SUPPORTS_ONE_ONLY) | |
| 568 cpp_define (pfile, "__GXX_WEAK__=1"); | |
| 569 else | |
| 570 cpp_define (pfile, "__GXX_WEAK__=0"); | |
| 571 if (warn_deprecated) | |
| 572 cpp_define (pfile, "__DEPRECATED"); | |
| 573 if (flag_rtti) | |
| 574 cpp_define (pfile, "__GXX_RTTI"); | |
| 575 if (cxx_dialect == cxx0x) | |
| 576 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__"); | |
| 577 } | |
| 578 /* Note that we define this for C as well, so that we know if | |
| 579 __attribute__((cleanup)) will interface with EH. */ | |
| 580 if (flag_exceptions) | |
| 581 cpp_define (pfile, "__EXCEPTIONS"); | |
| 582 | |
| 583 /* Represents the C++ ABI version, always defined so it can be used while | |
| 584 preprocessing C and assembler. */ | |
| 585 if (flag_abi_version == 0) | |
| 586 /* Use a very large value so that: | |
| 587 | |
| 588 #if __GXX_ABI_VERSION >= <value for version X> | |
| 589 | |
| 590 will work whether the user explicitly says "-fabi-version=x" or | |
| 591 "-fabi-version=0". Do not use INT_MAX because that will be | |
| 592 different from system to system. */ | |
| 593 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); | |
| 594 else if (flag_abi_version == 1) | |
| 595 /* Due to a historical accident, this version had the value | |
| 596 "102". */ | |
| 597 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); | |
| 598 else | |
| 599 /* Newer versions have values 1002, 1003, .... */ | |
| 600 builtin_define_with_int_value ("__GXX_ABI_VERSION", | |
| 601 1000 + flag_abi_version); | |
| 602 | |
| 603 /* libgcc needs to know this. */ | |
| 604 if (USING_SJLJ_EXCEPTIONS) | |
| 605 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); | |
| 606 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
607 /* limits.h and stdint.h need to know these. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
608 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
609 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
610 builtin_define_type_max ("__INT_MAX__", integer_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
611 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
612 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
613 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
614 underlying_wchar_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
615 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
616 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
617 builtin_define_type_max ("__SIZE_MAX__", size_type_node); |
| 0 | 618 |
| 619 builtin_define_type_precision ("__CHAR_BIT__", char_type_node); | |
| 620 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
621 /* stdint.h and the testsuite need to know these. */ |
| 0 | 622 builtin_define_stdint_macros (); |
| 623 | |
| 624 /* float.h needs to know these. */ | |
| 625 | |
| 626 builtin_define_with_int_value ("__FLT_EVAL_METHOD__", | |
| 627 TARGET_FLT_EVAL_METHOD); | |
| 628 | |
| 629 /* And decfloat.h needs this. */ | |
| 630 builtin_define_with_int_value ("__DEC_EVAL_METHOD__", | |
| 631 TARGET_DEC_EVAL_METHOD); | |
| 632 | |
| 633 builtin_define_float_constants ("FLT", "F", "%s", float_type_node); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
634 /* Cast the double precision constants. This is needed when single |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
635 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
636 is used. The correct result is computed by the compiler when using |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
637 macros that include a cast. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
638 builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); |
| 0 | 639 builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); |
| 640 | |
| 641 /* For decfloat.h. */ | |
| 642 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); | |
| 643 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); | |
| 644 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); | |
| 645 | |
| 646 /* For fixed-point fibt, ibit, max, min, and epsilon. */ | |
| 647 if (targetm.fixed_point_supported_p ()) | |
| 648 { | |
| 649 builtin_define_fixed_point_constants ("SFRACT", "HR", | |
| 650 short_fract_type_node); | |
| 651 builtin_define_fixed_point_constants ("USFRACT", "UHR", | |
| 652 unsigned_short_fract_type_node); | |
| 653 builtin_define_fixed_point_constants ("FRACT", "R", | |
| 654 fract_type_node); | |
| 655 builtin_define_fixed_point_constants ("UFRACT", "UR", | |
| 656 unsigned_fract_type_node); | |
| 657 builtin_define_fixed_point_constants ("LFRACT", "LR", | |
| 658 long_fract_type_node); | |
| 659 builtin_define_fixed_point_constants ("ULFRACT", "ULR", | |
| 660 unsigned_long_fract_type_node); | |
| 661 builtin_define_fixed_point_constants ("LLFRACT", "LLR", | |
| 662 long_long_fract_type_node); | |
| 663 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", | |
| 664 unsigned_long_long_fract_type_node); | |
| 665 builtin_define_fixed_point_constants ("SACCUM", "HK", | |
| 666 short_accum_type_node); | |
| 667 builtin_define_fixed_point_constants ("USACCUM", "UHK", | |
| 668 unsigned_short_accum_type_node); | |
| 669 builtin_define_fixed_point_constants ("ACCUM", "K", | |
| 670 accum_type_node); | |
| 671 builtin_define_fixed_point_constants ("UACCUM", "UK", | |
| 672 unsigned_accum_type_node); | |
| 673 builtin_define_fixed_point_constants ("LACCUM", "LK", | |
| 674 long_accum_type_node); | |
| 675 builtin_define_fixed_point_constants ("ULACCUM", "ULK", | |
| 676 unsigned_long_accum_type_node); | |
| 677 builtin_define_fixed_point_constants ("LLACCUM", "LLK", | |
| 678 long_long_accum_type_node); | |
| 679 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", | |
| 680 unsigned_long_long_accum_type_node); | |
| 681 | |
| 682 builtin_define_fixed_point_constants ("QQ", "", qq_type_node); | |
| 683 builtin_define_fixed_point_constants ("HQ", "", hq_type_node); | |
| 684 builtin_define_fixed_point_constants ("SQ", "", sq_type_node); | |
| 685 builtin_define_fixed_point_constants ("DQ", "", dq_type_node); | |
| 686 builtin_define_fixed_point_constants ("TQ", "", tq_type_node); | |
| 687 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); | |
| 688 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); | |
| 689 builtin_define_fixed_point_constants ("USQ", "", usq_type_node); | |
| 690 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); | |
| 691 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); | |
| 692 builtin_define_fixed_point_constants ("HA", "", ha_type_node); | |
| 693 builtin_define_fixed_point_constants ("SA", "", sa_type_node); | |
| 694 builtin_define_fixed_point_constants ("DA", "", da_type_node); | |
| 695 builtin_define_fixed_point_constants ("TA", "", ta_type_node); | |
| 696 builtin_define_fixed_point_constants ("UHA", "", uha_type_node); | |
| 697 builtin_define_fixed_point_constants ("USA", "", usa_type_node); | |
| 698 builtin_define_fixed_point_constants ("UDA", "", uda_type_node); | |
| 699 builtin_define_fixed_point_constants ("UTA", "", uta_type_node); | |
| 700 } | |
| 701 | |
| 702 /* For use in assembly language. */ | |
| 703 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); | |
| 704 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); | |
| 705 | |
| 706 /* Misc. */ | |
| 707 builtin_define_with_value ("__VERSION__", version_string, 1); | |
| 708 | |
| 709 if (flag_gnu89_inline) | |
| 710 cpp_define (pfile, "__GNUC_GNU_INLINE__"); | |
| 711 else | |
| 712 cpp_define (pfile, "__GNUC_STDC_INLINE__"); | |
| 713 | |
| 714 /* Definitions for LP64 model. */ | |
| 715 if (TYPE_PRECISION (long_integer_type_node) == 64 | |
| 716 && POINTER_SIZE == 64 | |
| 717 && TYPE_PRECISION (integer_type_node) == 32) | |
| 718 { | |
| 719 cpp_define (pfile, "_LP64"); | |
| 720 cpp_define (pfile, "__LP64__"); | |
| 721 } | |
| 722 | |
| 723 /* Other target-independent built-ins determined by command-line | |
| 724 options. */ | |
| 725 if (optimize_size) | |
| 726 cpp_define (pfile, "__OPTIMIZE_SIZE__"); | |
| 727 if (optimize) | |
| 728 cpp_define (pfile, "__OPTIMIZE__"); | |
| 729 | |
| 730 if (fast_math_flags_set_p ()) | |
| 731 cpp_define (pfile, "__FAST_MATH__"); | |
| 732 if (flag_no_inline) | |
| 733 cpp_define (pfile, "__NO_INLINE__"); | |
| 734 if (flag_signaling_nans) | |
| 735 cpp_define (pfile, "__SUPPORT_SNAN__"); | |
| 736 if (flag_finite_math_only) | |
| 737 cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); | |
| 738 else | |
| 739 cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); | |
| 740 if (flag_pic) | |
| 741 { | |
| 742 builtin_define_with_int_value ("__pic__", flag_pic); | |
| 743 builtin_define_with_int_value ("__PIC__", flag_pic); | |
| 744 } | |
| 745 if (flag_pie) | |
| 746 { | |
| 747 builtin_define_with_int_value ("__pie__", flag_pie); | |
| 748 builtin_define_with_int_value ("__PIE__", flag_pie); | |
| 749 } | |
| 750 | |
| 751 if (flag_iso) | |
| 752 cpp_define (pfile, "__STRICT_ANSI__"); | |
| 753 | |
| 754 if (!flag_signed_char) | |
| 755 cpp_define (pfile, "__CHAR_UNSIGNED__"); | |
| 756 | |
| 757 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) | |
| 758 cpp_define (pfile, "__WCHAR_UNSIGNED__"); | |
| 759 | |
| 760 /* Tell source code if the compiler makes sync_compare_and_swap | |
| 761 builtins available. */ | |
| 762 #ifdef HAVE_sync_compare_and_swapqi | |
| 763 if (HAVE_sync_compare_and_swapqi) | |
| 764 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); | |
| 765 #endif | |
| 766 | |
| 767 #ifdef HAVE_sync_compare_and_swaphi | |
| 768 if (HAVE_sync_compare_and_swaphi) | |
| 769 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); | |
| 770 #endif | |
| 771 | |
| 772 #ifdef HAVE_sync_compare_and_swapsi | |
| 773 if (HAVE_sync_compare_and_swapsi) | |
| 774 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); | |
| 775 #endif | |
| 776 | |
| 777 #ifdef HAVE_sync_compare_and_swapdi | |
| 778 if (HAVE_sync_compare_and_swapdi) | |
| 779 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); | |
| 780 #endif | |
| 781 | |
| 782 #ifdef HAVE_sync_compare_and_swapti | |
| 783 if (HAVE_sync_compare_and_swapti) | |
| 784 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); | |
| 785 #endif | |
| 786 | |
| 787 #ifdef DWARF2_UNWIND_INFO | |
| 788 if (dwarf2out_do_cfi_asm ()) | |
| 789 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); | |
| 790 #endif | |
| 791 | |
| 792 /* Make the choice of ObjC runtime visible to source code. */ | |
| 793 if (c_dialect_objc () && flag_next_runtime) | |
| 794 cpp_define (pfile, "__NEXT_RUNTIME__"); | |
| 795 | |
| 796 /* Show the availability of some target pragmas. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
797 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); |
| 0 | 798 |
| 799 if (targetm.handle_pragma_extern_prefix) | |
| 800 cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX"); | |
| 801 | |
| 802 /* Make the choice of the stack protector runtime visible to source code. | |
| 803 The macro names and values here were chosen for compatibility with an | |
| 804 earlier implementation, i.e. ProPolice. */ | |
| 805 if (flag_stack_protect == 2) | |
| 806 cpp_define (pfile, "__SSP_ALL__=2"); | |
| 807 else if (flag_stack_protect == 1) | |
| 808 cpp_define (pfile, "__SSP__=1"); | |
| 809 | |
| 810 if (flag_openmp) | |
| 811 cpp_define (pfile, "_OPENMP=200805"); | |
| 812 | |
| 813 builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node); | |
| 814 builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node); | |
| 815 builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__", | |
| 816 long_long_integer_type_node); | |
| 817 builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node); | |
| 818 builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node); | |
| 819 builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node); | |
| 820 builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node); | |
| 821 builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node); | |
| 822 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); | |
| 823 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); | |
| 824 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", | |
| 825 unsigned_ptrdiff_type_node); | |
| 826 /* ptr_type_node can't be used here since ptr_mode is only set when | |
| 827 toplev calls backend_init which is not done with -E switch. */ | |
| 828 builtin_define_with_int_value ("__SIZEOF_POINTER__", | |
| 829 POINTER_SIZE / BITS_PER_UNIT); | |
| 830 | |
| 831 /* A straightforward target hook doesn't work, because of problems | |
| 832 linking that hook's body when part of non-C front ends. */ | |
| 833 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) | |
| 834 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) | |
| 835 # define builtin_define(TXT) cpp_define (pfile, TXT) | |
| 836 # define builtin_assert(TXT) cpp_assert (pfile, TXT) | |
| 837 TARGET_CPU_CPP_BUILTINS (); | |
| 838 TARGET_OS_CPP_BUILTINS (); | |
| 839 TARGET_OBJFMT_CPP_BUILTINS (); | |
| 840 | |
| 841 /* Support the __declspec keyword by turning them into attributes. | |
| 842 Note that the current way we do this may result in a collision | |
| 843 with predefined attributes later on. This can be solved by using | |
| 844 one attribute, say __declspec__, and passing args to it. The | |
| 845 problem with that approach is that args are not accumulated: each | |
| 846 new appearance would clobber any existing args. */ | |
| 847 if (TARGET_DECLSPEC) | |
| 848 builtin_define ("__declspec(x)=__attribute__((x))"); | |
| 849 | |
| 850 /* If decimal floating point is supported, tell the user if the | |
| 851 alternate format (BID) is used instead of the standard (DPD) | |
| 852 format. */ | |
| 853 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) | |
| 854 cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); | |
| 855 | |
| 856 builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__", | |
| 857 BIGGEST_ALIGNMENT / BITS_PER_UNIT); | |
| 858 } | |
| 859 | |
| 860 /* Pass an object-like macro. If it doesn't lie in the user's | |
| 861 namespace, defines it unconditionally. Otherwise define a version | |
| 862 with two leading underscores, and another version with two leading | |
| 863 and trailing underscores, and define the original only if an ISO | |
| 864 standard was not nominated. | |
| 865 | |
| 866 e.g. passing "unix" defines "__unix", "__unix__" and possibly | |
| 867 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly | |
| 868 "_mips". */ | |
| 869 void | |
| 870 builtin_define_std (const char *macro) | |
| 871 { | |
| 872 size_t len = strlen (macro); | |
| 873 char *buff = (char *) alloca (len + 5); | |
| 874 char *p = buff + 2; | |
| 875 char *q = p + len; | |
| 876 | |
| 877 /* prepend __ (or maybe just _) if in user's namespace. */ | |
| 878 memcpy (p, macro, len + 1); | |
| 879 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) | |
| 880 { | |
| 881 if (*p != '_') | |
| 882 *--p = '_'; | |
| 883 if (p[1] != '_') | |
| 884 *--p = '_'; | |
| 885 } | |
| 886 cpp_define (parse_in, p); | |
| 887 | |
| 888 /* If it was in user's namespace... */ | |
| 889 if (p != buff + 2) | |
| 890 { | |
| 891 /* Define the macro with leading and following __. */ | |
| 892 if (q[-1] != '_') | |
| 893 *q++ = '_'; | |
| 894 if (q[-2] != '_') | |
| 895 *q++ = '_'; | |
| 896 *q = '\0'; | |
| 897 cpp_define (parse_in, p); | |
| 898 | |
| 899 /* Finally, define the original macro if permitted. */ | |
| 900 if (!flag_iso) | |
| 901 cpp_define (parse_in, macro); | |
| 902 } | |
| 903 } | |
| 904 | |
| 905 /* Pass an object-like macro and a value to define it to. The third | |
| 906 parameter says whether or not to turn the value into a string | |
| 907 constant. */ | |
| 908 void | |
| 909 builtin_define_with_value (const char *macro, const char *expansion, int is_str) | |
| 910 { | |
| 911 char *buf; | |
| 912 size_t mlen = strlen (macro); | |
| 913 size_t elen = strlen (expansion); | |
| 914 size_t extra = 2; /* space for an = and a NUL */ | |
| 915 | |
| 916 if (is_str) | |
| 917 extra += 2; /* space for two quote marks */ | |
| 918 | |
| 919 buf = (char *) alloca (mlen + elen + extra); | |
| 920 if (is_str) | |
| 921 sprintf (buf, "%s=\"%s\"", macro, expansion); | |
| 922 else | |
| 923 sprintf (buf, "%s=%s", macro, expansion); | |
| 924 | |
| 925 cpp_define (parse_in, buf); | |
| 926 } | |
| 927 | |
| 928 | |
| 929 /* Pass an object-like macro and an integer value to define it to. */ | |
| 930 static void | |
| 931 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) | |
| 932 { | |
| 933 char *buf; | |
| 934 size_t mlen = strlen (macro); | |
| 935 size_t vlen = 18; | |
| 936 size_t extra = 2; /* space for = and NUL. */ | |
| 937 | |
| 938 buf = (char *) alloca (mlen + vlen + extra); | |
| 939 memcpy (buf, macro, mlen); | |
| 940 buf[mlen] = '='; | |
| 941 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); | |
| 942 | |
| 943 cpp_define (parse_in, buf); | |
| 944 } | |
| 945 | |
| 946 /* Pass an object-like macro a hexadecimal floating-point value. */ | |
| 947 static void | |
| 948 builtin_define_with_hex_fp_value (const char *macro, | |
| 949 tree type, int digits, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
950 const char *hex_str, |
| 0 | 951 const char *fp_suffix, |
| 952 const char *fp_cast) | |
| 953 { | |
| 954 REAL_VALUE_TYPE real; | |
| 955 char dec_str[64], buf1[256], buf2[256]; | |
| 956 | |
| 957 /* Hex values are really cool and convenient, except that they're | |
| 958 not supported in strict ISO C90 mode. First, the "p-" sequence | |
| 959 is not valid as part of a preprocessor number. Second, we get a | |
| 960 pedwarn from the preprocessor, which has no context, so we can't | |
| 961 suppress the warning with __extension__. | |
| 962 | |
| 963 So instead what we do is construct the number in hex (because | |
| 964 it's easy to get the exact correct value), parse it as a real, | |
| 965 then print it back out as decimal. */ | |
| 966 | |
| 967 real_from_string (&real, hex_str); | |
| 968 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0, | |
| 969 TYPE_MODE (type)); | |
| 970 | |
| 971 /* Assemble the macro in the following fashion | |
| 972 macro = fp_cast [dec_str fp_suffix] */ | |
| 973 sprintf (buf1, "%s%s", dec_str, fp_suffix); | |
| 974 sprintf (buf2, fp_cast, buf1); | |
| 975 sprintf (buf1, "%s=%s", macro, buf2); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
976 |
| 0 | 977 cpp_define (parse_in, buf1); |
| 978 } | |
| 979 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
980 /* Return a string constant for the suffix for a value of type TYPE |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
981 promoted according to the integer promotions. The type must be one |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
982 of the standard integer type nodes. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
983 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
984 static const char * |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
985 type_suffix (tree type) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
986 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
987 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
988 int unsigned_suffix; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
989 int is_long; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
990 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
991 if (type == long_long_integer_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
992 || type == long_long_unsigned_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
993 is_long = 2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
994 else if (type == long_integer_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
995 || type == long_unsigned_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
996 is_long = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
997 else if (type == integer_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
998 || type == unsigned_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
999 || type == short_integer_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1000 || type == short_unsigned_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1001 || type == signed_char_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1002 || type == unsigned_char_type_node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1003 /* ??? "char" is not a signed or unsigned integer type and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1004 so is not permitted for the standard typedefs, but some |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1005 systems use it anyway. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1006 || type == char_type_node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1007 is_long = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1008 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1009 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1010 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1011 unsigned_suffix = TYPE_UNSIGNED (type); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1012 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1013 unsigned_suffix = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1014 return suffixes[is_long * 2 + unsigned_suffix]; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1015 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1016 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1017 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1018 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1019 builtin_define_constants (const char *macro, tree type) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1020 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1021 const char *suffix; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1022 char *buf; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1023 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1024 suffix = type_suffix (type); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1025 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1026 if (suffix[0] == 0) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1027 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1028 buf = (char *) alloca (strlen (macro) + 6); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1029 sprintf (buf, "%s(c)=c", macro); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1030 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1031 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1032 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1033 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1034 sprintf (buf, "%s(c)=c ## %s", macro, suffix); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1035 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1036 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1037 cpp_define (parse_in, buf); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1038 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1039 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1040 /* Define MAX for TYPE based on the precision of the type. */ |
| 0 | 1041 |
| 1042 static void | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1043 builtin_define_type_max (const char *macro, tree type) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1044 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1045 builtin_define_type_minmax (NULL, macro, type); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1046 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1047 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1048 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1049 precision of the type. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1050 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1051 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1052 builtin_define_type_minmax (const char *min_macro, const char *max_macro, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1053 tree type) |
| 0 | 1054 { |
| 1055 static const char *const values[] | |
| 1056 = { "127", "255", | |
| 1057 "32767", "65535", | |
| 1058 "2147483647", "4294967295", | |
| 1059 "9223372036854775807", "18446744073709551615", | |
| 1060 "170141183460469231731687303715884105727", | |
| 1061 "340282366920938463463374607431768211455" }; | |
| 1062 | |
| 1063 const char *value, *suffix; | |
| 1064 char *buf; | |
| 1065 size_t idx; | |
| 1066 | |
| 1067 /* Pre-rendering the values mean we don't have to futz with printing a | |
| 1068 multi-word decimal value. There are also a very limited number of | |
| 1069 precisions that we support, so it's really a waste of time. */ | |
| 1070 switch (TYPE_PRECISION (type)) | |
| 1071 { | |
| 1072 case 8: idx = 0; break; | |
| 1073 case 16: idx = 2; break; | |
| 1074 case 32: idx = 4; break; | |
| 1075 case 64: idx = 6; break; | |
| 1076 case 128: idx = 8; break; | |
| 1077 default: gcc_unreachable (); | |
| 1078 } | |
| 1079 | |
| 1080 value = values[idx + TYPE_UNSIGNED (type)]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1081 suffix = type_suffix (type); |
| 0 | 1082 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1083 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value) |
| 0 | 1084 + strlen (suffix) + 1); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1085 sprintf (buf, "%s=%s%s", max_macro, value, suffix); |
| 0 | 1086 |
| 1087 cpp_define (parse_in, buf); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1088 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1089 if (min_macro) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1090 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1091 if (TYPE_UNSIGNED (type)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1092 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1093 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1094 sprintf (buf, "%s=0%s", min_macro, suffix); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1095 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1096 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1097 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1098 buf = (char *) alloca (strlen (min_macro) + 3 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1099 + strlen (max_macro) + 6); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1100 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1101 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1102 cpp_define (parse_in, buf); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1103 } |
| 0 | 1104 } |