1 /* Define builtin-in macros for the C family front ends. 2 Copyright (C) 2002-2015 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12 WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "tm.h" 24 #include "hash-set.h" 25 #include "machmode.h" 26 #include "vec.h" 27 #include "double-int.h" 28 #include "input.h" 29 #include "alias.h" 30 #include "symtab.h" 31 #include "wide-int.h" 32 #include "inchash.h" 33 #include "tree.h" 34 #include "stor-layout.h" 35 #include "stringpool.h" 36 #include "version.h" 37 #include "flags.h" 38 #include "c-common.h" 39 #include "c-pragma.h" 40 #include "output.h" /* For user_label_prefix. */ 41 #include "debug.h" /* For dwarf2out_do_cfi_asm. */ 42 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */ 43 #include "target.h" 44 #include "common/common-target.h" 45 #include "cpp-id-data.h" 46 #include "cppbuiltin.h" 47 48 #ifndef TARGET_OS_CPP_BUILTINS 49 # define TARGET_OS_CPP_BUILTINS() 50 #endif 51 52 #ifndef TARGET_OBJFMT_CPP_BUILTINS 53 # define TARGET_OBJFMT_CPP_BUILTINS() 54 #endif 55 56 #ifndef REGISTER_PREFIX 57 #define REGISTER_PREFIX "" 58 #endif 59 60 /* Non-static as some targets don't use it. */ 61 void builtin_define_std (const char *) ATTRIBUTE_UNUSED; 62 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT); 63 static void builtin_define_with_hex_fp_value (const char *, tree, 64 int, const char *, 65 const char *, 66 const char *); 67 static void builtin_define_stdint_macros (void); 68 static void builtin_define_constants (const char *, tree); 69 static void builtin_define_type_max (const char *, tree); 70 static void builtin_define_type_minmax (const char *, const char *, tree); 71 static void builtin_define_type_sizeof (const char *, tree); 72 static void builtin_define_float_constants (const char *, 73 const char *, 74 const char *, 75 const char *, 76 tree); 77 78 /* Return true if MODE provides a fast multiply/add (FMA) builtin function. 79 Originally this function used the fma optab, but that doesn't work with 80 -save-temps, so just rely on the HAVE_fma macros for the standard floating 81 point types. */ 82 83 static bool 84 mode_has_fma (machine_mode mode) 85 { 86 switch (mode) 87 { 88 #ifdef HAVE_fmasf4 89 case SFmode: 90 return !!HAVE_fmasf4; 91 #endif 92 93 #ifdef HAVE_fmadf4 94 case DFmode: 95 return !!HAVE_fmadf4; 96 #endif 97 98 #ifdef HAVE_fmaxf4 99 case XFmode: 100 return !!HAVE_fmaxf4; 101 #endif 102 103 #ifdef HAVE_fmatf4 104 case TFmode: 105 return !!HAVE_fmatf4; 106 #endif 107 108 default: 109 break; 110 } 111 112 return false; 113 } 114 115 /* Define NAME with value TYPE size_unit. */ 116 static void 117 builtin_define_type_sizeof (const char *name, tree type) 118 { 119 builtin_define_with_int_value (name, 120 tree_to_uhwi (TYPE_SIZE_UNIT (type))); 121 } 122 123 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX, 124 and FP_CAST. */ 125 static void 126 builtin_define_float_constants (const char *name_prefix, 127 const char *fp_suffix, 128 const char *fp_cast, 129 const char *fma_suffix, 130 tree type) 131 { 132 /* Used to convert radix-based values to base 10 values in several cases. 133 134 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at 135 least 6 significant digits for correct results. Using the fraction 136 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an 137 intermediate; perhaps someone can find a better approximation, in the 138 mean time, I suspect using doubles won't harm the bootstrap here. */ 139 140 const double log10_2 = .30102999566398119521; 141 double log10_b; 142 const struct real_format *fmt; 143 const struct real_format *ldfmt; 144 145 char name[64], buf[128]; 146 int dig, min_10_exp, max_10_exp; 147 int decimal_dig; 148 int type_decimal_dig; 149 150 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 151 gcc_assert (fmt->b != 10); 152 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node)); 153 gcc_assert (ldfmt->b != 10); 154 155 /* The radix of the exponent representation. */ 156 if (type == float_type_node) 157 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b); 158 log10_b = log10_2; 159 160 /* The number of radix digits, p, in the floating-point significand. */ 161 sprintf (name, "__%s_MANT_DIG__", name_prefix); 162 builtin_define_with_int_value (name, fmt->p); 163 164 /* The number of decimal digits, q, such that any floating-point number 165 with q decimal digits can be rounded into a floating-point number with 166 p radix b digits and back again without change to the q decimal digits, 167 168 p log10 b if b is a power of 10 169 floor((p - 1) log10 b) otherwise 170 */ 171 dig = (fmt->p - 1) * log10_b; 172 sprintf (name, "__%s_DIG__", name_prefix); 173 builtin_define_with_int_value (name, dig); 174 175 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 176 sprintf (name, "__%s_MIN_EXP__", name_prefix); 177 sprintf (buf, "(%d)", fmt->emin); 178 builtin_define_with_value (name, buf, 0); 179 180 /* The minimum negative int x such that 10**x is a normalized float, 181 182 ceil (log10 (b ** (emin - 1))) 183 = ceil (log10 (b) * (emin - 1)) 184 185 Recall that emin is negative, so the integer truncation calculates 186 the ceiling, not the floor, in this case. */ 187 min_10_exp = (fmt->emin - 1) * log10_b; 188 sprintf (name, "__%s_MIN_10_EXP__", name_prefix); 189 sprintf (buf, "(%d)", min_10_exp); 190 builtin_define_with_value (name, buf, 0); 191 192 /* The maximum int x such that b**(x-1) is a representable float. */ 193 sprintf (name, "__%s_MAX_EXP__", name_prefix); 194 builtin_define_with_int_value (name, fmt->emax); 195 196 /* The maximum int x such that 10**x is in the range of representable 197 finite floating-point numbers, 198 199 floor (log10((1 - b**-p) * b**emax)) 200 = floor (log10(1 - b**-p) + log10(b**emax)) 201 = floor (log10(1 - b**-p) + log10(b)*emax) 202 203 The safest thing to do here is to just compute this number. But since 204 we don't link cc1 with libm, we cannot. We could implement log10 here 205 a series expansion, but that seems too much effort because: 206 207 Note that the first term, for all extant p, is a number exceedingly close 208 to zero, but slightly negative. Note that the second term is an integer 209 scaling an irrational number, and that because of the floor we are only 210 interested in its integral portion. 211 212 In order for the first term to have any effect on the integral portion 213 of the second term, the second term has to be exceedingly close to an 214 integer itself (e.g. 123.000000000001 or something). Getting a result 215 that close to an integer requires that the irrational multiplicand have 216 a long series of zeros in its expansion, which doesn't occur in the 217 first 20 digits or so of log10(b). 218 219 Hand-waving aside, crunching all of the sets of constants above by hand 220 does not yield a case for which the first term is significant, which 221 in the end is all that matters. */ 222 max_10_exp = fmt->emax * log10_b; 223 sprintf (name, "__%s_MAX_10_EXP__", name_prefix); 224 builtin_define_with_int_value (name, max_10_exp); 225 226 /* The number of decimal digits, n, such that any floating-point number 227 can be rounded to n decimal digits and back again without change to 228 the value. 229 230 p * log10(b) if b is a power of 10 231 ceil(1 + p * log10(b)) otherwise 232 233 The only macro we care about is this number for the widest supported 234 floating type, but we want this value for rendering constants below. */ 235 { 236 double d_decimal_dig 237 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b; 238 decimal_dig = d_decimal_dig; 239 if (decimal_dig < d_decimal_dig) 240 decimal_dig++; 241 } 242 /* Similar, for this type rather than long double. */ 243 { 244 double type_d_decimal_dig = 1 + fmt->p * log10_b; 245 type_decimal_dig = type_d_decimal_dig; 246 if (type_decimal_dig < type_d_decimal_dig) 247 type_decimal_dig++; 248 } 249 if (type == long_double_type_node) 250 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig); 251 else 252 { 253 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix); 254 builtin_define_with_int_value (name, type_decimal_dig); 255 } 256 257 /* Since, for the supported formats, B is always a power of 2, we 258 construct the following numbers directly as a hexadecimal 259 constants. */ 260 get_max_float (fmt, buf, sizeof (buf)); 261 262 sprintf (name, "__%s_MAX__", name_prefix); 263 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 264 265 /* The minimum normalized positive floating-point number, 266 b**(emin-1). */ 267 sprintf (name, "__%s_MIN__", name_prefix); 268 sprintf (buf, "0x1p%d", fmt->emin - 1); 269 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 270 271 /* The difference between 1 and the least value greater than 1 that is 272 representable in the given floating point type, b**(1-p). */ 273 sprintf (name, "__%s_EPSILON__", name_prefix); 274 if (fmt->pnan < fmt->p) 275 /* This is an IBM extended double format, so 1.0 + any double is 276 representable precisely. */ 277 sprintf (buf, "0x1p%d", fmt->emin - fmt->p); 278 else 279 sprintf (buf, "0x1p%d", 1 - fmt->p); 280 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 281 282 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN. 283 The minimum denormalized positive floating-point number, b**(emin-p). 284 The minimum normalized positive floating-point number for formats 285 that don't support denormals. */ 286 sprintf (name, "__%s_DENORM_MIN__", name_prefix); 287 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1)); 288 builtin_define_with_hex_fp_value (name, type, decimal_dig, 289 buf, fp_suffix, fp_cast); 290 291 sprintf (name, "__%s_HAS_DENORM__", name_prefix); 292 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0); 293 294 /* For C++ std::numeric_limits<T>::has_infinity. */ 295 sprintf (name, "__%s_HAS_INFINITY__", name_prefix); 296 builtin_define_with_int_value (name, 297 MODE_HAS_INFINITIES (TYPE_MODE (type))); 298 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a 299 predicate to distinguish a target that has both quiet and 300 signalling NaNs from a target that has only quiet NaNs or only 301 signalling NaNs, so we assume that a target that has any kind of 302 NaN has quiet NaNs. */ 303 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix); 304 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type))); 305 306 /* Note whether we have fast FMA. */ 307 if (mode_has_fma (TYPE_MODE (type))) 308 { 309 sprintf (name, "__FP_FAST_FMA%s", fma_suffix); 310 builtin_define_with_int_value (name, 1); 311 } 312 } 313 314 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */ 315 static void 316 builtin_define_decimal_float_constants (const char *name_prefix, 317 const char *suffix, 318 tree type) 319 { 320 const struct real_format *fmt; 321 char name[64], buf[128], *p; 322 int digits; 323 324 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 325 326 /* The number of radix digits, p, in the significand. */ 327 sprintf (name, "__%s_MANT_DIG__", name_prefix); 328 builtin_define_with_int_value (name, fmt->p); 329 330 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 331 sprintf (name, "__%s_MIN_EXP__", name_prefix); 332 sprintf (buf, "(%d)", fmt->emin); 333 builtin_define_with_value (name, buf, 0); 334 335 /* The maximum int x such that b**(x-1) is a representable float. */ 336 sprintf (name, "__%s_MAX_EXP__", name_prefix); 337 builtin_define_with_int_value (name, fmt->emax); 338 339 /* Compute the minimum representable value. */ 340 sprintf (name, "__%s_MIN__", name_prefix); 341 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix); 342 builtin_define_with_value (name, buf, 0); 343 344 /* Compute the maximum representable value. */ 345 sprintf (name, "__%s_MAX__", name_prefix); 346 p = buf; 347 for (digits = fmt->p; digits; digits--) 348 { 349 *p++ = '9'; 350 if (digits == fmt->p) 351 *p++ = '.'; 352 } 353 *p = 0; 354 /* fmt->p plus 1, to account for the decimal point and fmt->emax 355 minus 1 because the digits are nines, not 1.0. */ 356 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix); 357 builtin_define_with_value (name, buf, 0); 358 359 /* Compute epsilon (the difference between 1 and least value greater 360 than 1 representable). */ 361 sprintf (name, "__%s_EPSILON__", name_prefix); 362 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix); 363 builtin_define_with_value (name, buf, 0); 364 365 /* Minimum subnormal positive decimal value. */ 366 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix); 367 p = buf; 368 for (digits = fmt->p; digits > 1; digits--) 369 { 370 *p++ = '0'; 371 if (digits == fmt->p) 372 *p++ = '.'; 373 } 374 *p = 0; 375 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix); 376 builtin_define_with_value (name, buf, 0); 377 } 378 379 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */ 380 381 static void 382 builtin_define_fixed_point_constants (const char *name_prefix, 383 const char *suffix, 384 tree type) 385 { 386 char name[64], buf[256], *new_buf; 387 int i, mod; 388 389 sprintf (name, "__%s_FBIT__", name_prefix); 390 builtin_define_with_int_value (name, TYPE_FBIT (type)); 391 392 sprintf (name, "__%s_IBIT__", name_prefix); 393 builtin_define_with_int_value (name, TYPE_IBIT (type)); 394 395 /* If there is no suffix, defines are for fixed-point modes. 396 We just return. */ 397 if (strcmp (suffix, "") == 0) 398 return; 399 400 if (TYPE_UNSIGNED (type)) 401 { 402 sprintf (name, "__%s_MIN__", name_prefix); 403 sprintf (buf, "0.0%s", suffix); 404 builtin_define_with_value (name, buf, 0); 405 } 406 else 407 { 408 sprintf (name, "__%s_MIN__", name_prefix); 409 if (ALL_ACCUM_MODE_P (TYPE_MODE (type))) 410 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix, 411 TYPE_IBIT (type) - 1, suffix); 412 else 413 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix); 414 builtin_define_with_value (name, buf, 0); 415 } 416 417 sprintf (name, "__%s_MAX__", name_prefix); 418 sprintf (buf, "0X"); 419 new_buf = buf + 2; 420 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4; 421 if (mod) 422 sprintf (new_buf++, "%x", (1 << mod) - 1); 423 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++) 424 sprintf (new_buf++, "F"); 425 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix); 426 builtin_define_with_value (name, buf, 0); 427 428 sprintf (name, "__%s_EPSILON__", name_prefix); 429 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix); 430 builtin_define_with_value (name, buf, 0); 431 } 432 433 /* Define macros used by <stdint.h>. */ 434 static void 435 builtin_define_stdint_macros (void) 436 { 437 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node); 438 builtin_define_constants ("__INTMAX_C", intmax_type_node); 439 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node); 440 builtin_define_constants ("__UINTMAX_C", uintmax_type_node); 441 if (sig_atomic_type_node) 442 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__", 443 sig_atomic_type_node); 444 if (int8_type_node) 445 builtin_define_type_max ("__INT8_MAX__", int8_type_node); 446 if (int16_type_node) 447 builtin_define_type_max ("__INT16_MAX__", int16_type_node); 448 if (int32_type_node) 449 builtin_define_type_max ("__INT32_MAX__", int32_type_node); 450 if (int64_type_node) 451 builtin_define_type_max ("__INT64_MAX__", int64_type_node); 452 if (uint8_type_node) 453 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node); 454 if (c_uint16_type_node) 455 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node); 456 if (c_uint32_type_node) 457 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node); 458 if (c_uint64_type_node) 459 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node); 460 if (int_least8_type_node) 461 { 462 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node); 463 builtin_define_constants ("__INT8_C", int_least8_type_node); 464 } 465 if (int_least16_type_node) 466 { 467 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node); 468 builtin_define_constants ("__INT16_C", int_least16_type_node); 469 } 470 if (int_least32_type_node) 471 { 472 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node); 473 builtin_define_constants ("__INT32_C", int_least32_type_node); 474 } 475 if (int_least64_type_node) 476 { 477 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node); 478 builtin_define_constants ("__INT64_C", int_least64_type_node); 479 } 480 if (uint_least8_type_node) 481 { 482 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node); 483 builtin_define_constants ("__UINT8_C", uint_least8_type_node); 484 } 485 if (uint_least16_type_node) 486 { 487 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node); 488 builtin_define_constants ("__UINT16_C", uint_least16_type_node); 489 } 490 if (uint_least32_type_node) 491 { 492 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node); 493 builtin_define_constants ("__UINT32_C", uint_least32_type_node); 494 } 495 if (uint_least64_type_node) 496 { 497 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node); 498 builtin_define_constants ("__UINT64_C", uint_least64_type_node); 499 } 500 if (int_fast8_type_node) 501 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node); 502 if (int_fast16_type_node) 503 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node); 504 if (int_fast32_type_node) 505 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node); 506 if (int_fast64_type_node) 507 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node); 508 if (uint_fast8_type_node) 509 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node); 510 if (uint_fast16_type_node) 511 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node); 512 if (uint_fast32_type_node) 513 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node); 514 if (uint_fast64_type_node) 515 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node); 516 if (intptr_type_node) 517 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node); 518 if (uintptr_type_node) 519 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node); 520 } 521 522 /* Adjust the optimization macros when a #pragma GCC optimization is done to 523 reflect the current level. */ 524 void 525 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree, 526 tree cur_tree) 527 { 528 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree); 529 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree); 530 bool prev_fast_math; 531 bool cur_fast_math; 532 533 /* -undef turns off target-specific built-ins. */ 534 if (flag_undef) 535 return; 536 537 /* Other target-independent built-ins determined by command-line 538 options. */ 539 if (!prev->x_optimize_size && cur->x_optimize_size) 540 cpp_define (pfile, "__OPTIMIZE_SIZE__"); 541 else if (prev->x_optimize_size && !cur->x_optimize_size) 542 cpp_undef (pfile, "__OPTIMIZE_SIZE__"); 543 544 if (!prev->x_optimize && cur->x_optimize) 545 cpp_define (pfile, "__OPTIMIZE__"); 546 else if (prev->x_optimize && !cur->x_optimize) 547 cpp_undef (pfile, "__OPTIMIZE__"); 548 549 prev_fast_math = fast_math_flags_struct_set_p (prev); 550 cur_fast_math = fast_math_flags_struct_set_p (cur); 551 if (!prev_fast_math && cur_fast_math) 552 cpp_define (pfile, "__FAST_MATH__"); 553 else if (prev_fast_math && !cur_fast_math) 554 cpp_undef (pfile, "__FAST_MATH__"); 555 556 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans) 557 cpp_define (pfile, "__SUPPORT_SNAN__"); 558 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans) 559 cpp_undef (pfile, "__SUPPORT_SNAN__"); 560 561 if (!prev->x_flag_errno_math && cur->x_flag_errno_math) 562 cpp_undef (pfile, "__NO_MATH_ERRNO__"); 563 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math) 564 cpp_define (pfile, "__NO_MATH_ERRNO__"); 565 566 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only) 567 { 568 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); 569 cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); 570 } 571 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only) 572 { 573 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); 574 cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); 575 } 576 } 577 578 579 /* This function will emit cpp macros to indicate the presence of various lock 580 free atomic operations. */ 581 582 static void 583 cpp_atomic_builtins (cpp_reader *pfile) 584 { 585 /* Set a flag for each size of object that compare and swap exists for up to 586 a 16 byte object. */ 587 #define SWAP_LIMIT 17 588 bool have_swap[SWAP_LIMIT]; 589 unsigned int psize; 590 591 /* Clear the map of sizes compare_and swap exists for. */ 592 memset (have_swap, 0, sizeof (have_swap)); 593 594 /* Tell source code if the compiler makes sync_compare_and_swap 595 builtins available. */ 596 #ifndef HAVE_sync_compare_and_swapqi 597 #define HAVE_sync_compare_and_swapqi 0 598 #endif 599 #ifndef HAVE_atomic_compare_and_swapqi 600 #define HAVE_atomic_compare_and_swapqi 0 601 #endif 602 603 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi) 604 { 605 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 606 have_swap[1] = true; 607 } 608 609 #ifndef HAVE_sync_compare_and_swaphi 610 #define HAVE_sync_compare_and_swaphi 0 611 #endif 612 #ifndef HAVE_atomic_compare_and_swaphi 613 #define HAVE_atomic_compare_and_swaphi 0 614 #endif 615 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi) 616 { 617 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 618 have_swap[2] = true; 619 } 620 621 #ifndef HAVE_sync_compare_and_swapsi 622 #define HAVE_sync_compare_and_swapsi 0 623 #endif 624 #ifndef HAVE_atomic_compare_and_swapsi 625 #define HAVE_atomic_compare_and_swapsi 0 626 #endif 627 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi) 628 { 629 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 630 have_swap[4] = true; 631 } 632 633 #ifndef HAVE_sync_compare_and_swapdi 634 #define HAVE_sync_compare_and_swapdi 0 635 #endif 636 #ifndef HAVE_atomic_compare_and_swapdi 637 #define HAVE_atomic_compare_and_swapdi 0 638 #endif 639 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi) 640 { 641 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 642 have_swap[8] = true; 643 } 644 645 #ifndef HAVE_sync_compare_and_swapti 646 #define HAVE_sync_compare_and_swapti 0 647 #endif 648 #ifndef HAVE_atomic_compare_and_swapti 649 #define HAVE_atomic_compare_and_swapti 0 650 #endif 651 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti) 652 { 653 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); 654 have_swap[16] = true; 655 } 656 657 /* Tell the source code about various types. These map to the C++11 and C11 658 macros where 2 indicates lock-free always, and 1 indicates sometimes 659 lock free. */ 660 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T))) 661 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0) 662 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE", 663 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1)); 664 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE", 665 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1)); 666 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE", 667 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1)); 668 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE", 669 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1)); 670 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE", 671 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1)); 672 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE", 673 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1)); 674 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE", 675 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1)); 676 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE", 677 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1)); 678 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE", 679 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1)); 680 681 /* If we're dealing with a "set" value that doesn't exactly correspond 682 to a boolean truth value, let the library work around that. */ 683 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", 684 targetm.atomic_test_and_set_trueval); 685 686 /* ptr_type_node can't be used here since ptr_mode is only set when 687 toplev calls backend_init which is not done with -E or pch. */ 688 psize = POINTER_SIZE_UNITS; 689 if (psize >= SWAP_LIMIT) 690 psize = 0; 691 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE", 692 (have_swap[psize]? 2 : 1)); 693 } 694 695 /* Return the value for __GCC_IEC_559. */ 696 static int 697 cpp_iec_559_value (void) 698 { 699 /* The default is support for IEEE 754-2008. */ 700 int ret = 2; 701 702 /* float and double must be binary32 and binary64. If they are but 703 with reversed NaN convention, at most IEEE 754-1985 is 704 supported. */ 705 const struct real_format *ffmt 706 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node)); 707 const struct real_format *dfmt 708 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node)); 709 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set) 710 ret = 1; 711 if (ffmt->b != 2 712 || ffmt->p != 24 713 || ffmt->pnan != 24 714 || ffmt->emin != -125 715 || ffmt->emax != 128 716 || ffmt->signbit_rw != 31 717 || ffmt->round_towards_zero 718 || !ffmt->has_sign_dependent_rounding 719 || !ffmt->has_nans 720 || !ffmt->has_inf 721 || !ffmt->has_denorm 722 || !ffmt->has_signed_zero 723 || dfmt->b != 2 724 || dfmt->p != 53 725 || dfmt->pnan != 53 726 || dfmt->emin != -1021 727 || dfmt->emax != 1024 728 || dfmt->signbit_rw != 63 729 || dfmt->round_towards_zero 730 || !dfmt->has_sign_dependent_rounding 731 || !dfmt->has_nans 732 || !dfmt->has_inf 733 || !dfmt->has_denorm 734 || !dfmt->has_signed_zero) 735 ret = 0; 736 737 /* In strict C standards conformance mode, consider unpredictable 738 excess precision to mean lack of IEEE 754 support. The same 739 applies to unpredictable contraction. For C++, and outside 740 strict conformance mode, do not consider these options to mean 741 lack of IEEE 754 support. */ 742 if (flag_iso 743 && !c_dialect_cxx () 744 && TARGET_FLT_EVAL_METHOD != 0 745 && flag_excess_precision_cmdline != EXCESS_PRECISION_STANDARD) 746 ret = 0; 747 if (flag_iso 748 && !c_dialect_cxx () 749 && flag_fp_contract_mode == FP_CONTRACT_FAST) 750 ret = 0; 751 752 /* Various options are contrary to IEEE 754 semantics. */ 753 if (flag_unsafe_math_optimizations 754 || flag_associative_math 755 || flag_reciprocal_math 756 || flag_finite_math_only 757 || !flag_signed_zeros 758 || flag_single_precision_constant) 759 ret = 0; 760 761 /* If the target does not support IEEE 754 exceptions and rounding 762 modes, consider IEEE 754 support to be absent. */ 763 if (!targetm.float_exceptions_rounding_supported_p ()) 764 ret = 0; 765 766 return ret; 767 } 768 769 /* Return the value for __GCC_IEC_559_COMPLEX. */ 770 static int 771 cpp_iec_559_complex_value (void) 772 { 773 /* The value is no bigger than that of __GCC_IEC_559. */ 774 int ret = cpp_iec_559_value (); 775 776 /* Some options are contrary to the required default state of the 777 CX_LIMITED_RANGE pragma. */ 778 if (flag_complex_method != 2) 779 ret = 0; 780 781 return ret; 782 } 783 784 /* Hook that registers front end and target-specific built-ins. */ 785 void 786 c_cpp_builtins (cpp_reader *pfile) 787 { 788 int i; 789 790 /* -undef turns off target-specific built-ins. */ 791 if (flag_undef) 792 return; 793 794 define_language_independent_builtin_macros (pfile); 795 796 if (c_dialect_cxx ()) 797 { 798 int major; 799 parse_basever (&major, NULL, NULL); 800 cpp_define_formatted (pfile, "__GNUG__=%d", major); 801 } 802 803 /* For stddef.h. They require macros defined in c-common.c. */ 804 c_stddef_cpp_builtins (); 805 806 /* Set include test macros for all C/C++ (not for just C++11 etc.) 807 The builtins __has_include__ and __has_include_next__ are defined 808 in libcpp. */ 809 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)"); 810 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)"); 811 812 if (c_dialect_cxx ()) 813 { 814 if (flag_weak && SUPPORTS_ONE_ONLY) 815 cpp_define (pfile, "__GXX_WEAK__=1"); 816 else 817 cpp_define (pfile, "__GXX_WEAK__=0"); 818 819 if (warn_deprecated) 820 cpp_define (pfile, "__DEPRECATED"); 821 822 if (flag_rtti) 823 { 824 cpp_define (pfile, "__GXX_RTTI"); 825 cpp_define (pfile, "__cpp_rtti=199711"); 826 } 827 828 if (cxx_dialect >= cxx11) 829 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__"); 830 831 /* Binary literals have been allowed in g++ before C++11 832 and were standardized for C++14. */ 833 if (!pedantic || cxx_dialect > cxx11) 834 cpp_define (pfile, "__cpp_binary_literals=201304"); 835 836 /* Arrays of runtime bound were removed from C++14, but we still 837 support GNU VLAs. Let's define this macro to a low number 838 (corresponding to the initial test release of GNU C++) if we won't 839 complain about use of VLAs. */ 840 if (c_dialect_cxx () 841 && (pedantic ? warn_vla == 0 : warn_vla <= 0)) 842 cpp_define (pfile, "__cpp_runtime_arrays=198712"); 843 844 if (cxx_dialect >= cxx11) 845 { 846 /* Set feature test macros for C++11 */ 847 cpp_define (pfile, "__cpp_unicode_characters=200704"); 848 cpp_define (pfile, "__cpp_raw_strings=200710"); 849 cpp_define (pfile, "__cpp_unicode_literals=200710"); 850 cpp_define (pfile, "__cpp_user_defined_literals=200809"); 851 cpp_define (pfile, "__cpp_lambdas=200907"); 852 if (cxx_dialect == cxx11) 853 cpp_define (pfile, "__cpp_constexpr=200704"); 854 cpp_define (pfile, "__cpp_range_based_for=200907"); 855 cpp_define (pfile, "__cpp_static_assert=200410"); 856 cpp_define (pfile, "__cpp_decltype=200707"); 857 cpp_define (pfile, "__cpp_attributes=200809"); 858 cpp_define (pfile, "__cpp_rvalue_reference=200610"); 859 cpp_define (pfile, "__cpp_rvalue_references=200610"); 860 cpp_define (pfile, "__cpp_variadic_templates=200704"); 861 cpp_define (pfile, "__cpp_initializer_lists=200806"); 862 cpp_define (pfile, "__cpp_delegating_constructors=200604"); 863 cpp_define (pfile, "__cpp_nsdmi=200809"); 864 cpp_define (pfile, "__cpp_inheriting_constructors=200802"); 865 cpp_define (pfile, "__cpp_ref_qualifiers=200710"); 866 cpp_define (pfile, "__cpp_alias_templates=200704"); 867 } 868 if (cxx_dialect > cxx11) 869 { 870 /* Set feature test macros for C++14 */ 871 cpp_define (pfile, "__cpp_return_type_deduction=201304"); 872 cpp_define (pfile, "__cpp_init_captures=201304"); 873 cpp_define (pfile, "__cpp_generic_lambdas=201304"); 874 cpp_define (pfile, "__cpp_constexpr=201304"); 875 cpp_define (pfile, "__cpp_decltype_auto=201304"); 876 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304"); 877 cpp_define (pfile, "__cpp_variable_templates=201304"); 878 cpp_define (pfile, "__cpp_digit_separators=201309"); 879 } 880 if (flag_sized_deallocation) 881 cpp_define (pfile, "__cpp_sized_deallocation=201309"); 882 if (flag_threadsafe_statics) 883 cpp_define (pfile, "__cpp_threadsafe_static_init=200806"); 884 } 885 /* Note that we define this for C as well, so that we know if 886 __attribute__((cleanup)) will interface with EH. */ 887 if (flag_exceptions) 888 { 889 cpp_define (pfile, "__EXCEPTIONS"); 890 if (c_dialect_cxx ()) 891 cpp_define (pfile, "__cpp_exceptions=199711"); 892 } 893 894 /* Represents the C++ ABI version, always defined so it can be used while 895 preprocessing C and assembler. */ 896 if (flag_abi_version == 0) 897 /* We should have set this to something real in c_common_post_options. */ 898 gcc_unreachable (); 899 else if (flag_abi_version == 1) 900 /* Due to a historical accident, this version had the value 901 "102". */ 902 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); 903 else 904 /* Newer versions have values 1002, 1003, .... */ 905 builtin_define_with_int_value ("__GXX_ABI_VERSION", 906 1000 + flag_abi_version); 907 908 /* libgcc needs to know this. */ 909 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 910 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); 911 912 /* limits.h and stdint.h need to know these. */ 913 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node); 914 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node); 915 builtin_define_type_max ("__INT_MAX__", integer_type_node); 916 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node); 917 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node); 918 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__", 919 underlying_wchar_type_node); 920 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node); 921 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node); 922 builtin_define_type_max ("__SIZE_MAX__", size_type_node); 923 924 if (c_dialect_cxx ()) 925 for (i = 0; i < NUM_INT_N_ENTS; i ++) 926 if (int_n_enabled_p[i]) 927 { 928 char buf[35+20+20]; 929 930 /* These are used to configure the C++ library. */ 931 932 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE) 933 { 934 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize); 935 cpp_define (parse_in, buf); 936 937 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize); 938 cpp_define (parse_in, buf); 939 } 940 } 941 942 /* stdint.h and the testsuite need to know these. */ 943 builtin_define_stdint_macros (); 944 945 /* Provide information for library headers to determine whether to 946 define macros such as __STDC_IEC_559__ and 947 __STDC_IEC_559_COMPLEX__. */ 948 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ()); 949 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX", 950 cpp_iec_559_complex_value ()); 951 952 /* float.h needs to know this. */ 953 builtin_define_with_int_value ("__FLT_EVAL_METHOD__", 954 TARGET_FLT_EVAL_METHOD); 955 956 /* And decfloat.h needs this. */ 957 builtin_define_with_int_value ("__DEC_EVAL_METHOD__", 958 TARGET_DEC_EVAL_METHOD); 959 960 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node); 961 /* Cast the double precision constants. This is needed when single 962 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64 963 is used. The correct result is computed by the compiler when using 964 macros that include a cast. We use a different cast for C++ to avoid 965 problems with -Wold-style-cast. */ 966 builtin_define_float_constants ("DBL", "L", 967 (c_dialect_cxx () 968 ? "double(%s)" 969 : "((double)%s)"), 970 "", double_type_node); 971 builtin_define_float_constants ("LDBL", "L", "%s", "L", 972 long_double_type_node); 973 974 /* For decfloat.h. */ 975 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); 976 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); 977 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); 978 979 /* For fixed-point fibt, ibit, max, min, and epsilon. */ 980 if (targetm.fixed_point_supported_p ()) 981 { 982 builtin_define_fixed_point_constants ("SFRACT", "HR", 983 short_fract_type_node); 984 builtin_define_fixed_point_constants ("USFRACT", "UHR", 985 unsigned_short_fract_type_node); 986 builtin_define_fixed_point_constants ("FRACT", "R", 987 fract_type_node); 988 builtin_define_fixed_point_constants ("UFRACT", "UR", 989 unsigned_fract_type_node); 990 builtin_define_fixed_point_constants ("LFRACT", "LR", 991 long_fract_type_node); 992 builtin_define_fixed_point_constants ("ULFRACT", "ULR", 993 unsigned_long_fract_type_node); 994 builtin_define_fixed_point_constants ("LLFRACT", "LLR", 995 long_long_fract_type_node); 996 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", 997 unsigned_long_long_fract_type_node); 998 builtin_define_fixed_point_constants ("SACCUM", "HK", 999 short_accum_type_node); 1000 builtin_define_fixed_point_constants ("USACCUM", "UHK", 1001 unsigned_short_accum_type_node); 1002 builtin_define_fixed_point_constants ("ACCUM", "K", 1003 accum_type_node); 1004 builtin_define_fixed_point_constants ("UACCUM", "UK", 1005 unsigned_accum_type_node); 1006 builtin_define_fixed_point_constants ("LACCUM", "LK", 1007 long_accum_type_node); 1008 builtin_define_fixed_point_constants ("ULACCUM", "ULK", 1009 unsigned_long_accum_type_node); 1010 builtin_define_fixed_point_constants ("LLACCUM", "LLK", 1011 long_long_accum_type_node); 1012 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", 1013 unsigned_long_long_accum_type_node); 1014 1015 builtin_define_fixed_point_constants ("QQ", "", qq_type_node); 1016 builtin_define_fixed_point_constants ("HQ", "", hq_type_node); 1017 builtin_define_fixed_point_constants ("SQ", "", sq_type_node); 1018 builtin_define_fixed_point_constants ("DQ", "", dq_type_node); 1019 builtin_define_fixed_point_constants ("TQ", "", tq_type_node); 1020 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); 1021 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); 1022 builtin_define_fixed_point_constants ("USQ", "", usq_type_node); 1023 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); 1024 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); 1025 builtin_define_fixed_point_constants ("HA", "", ha_type_node); 1026 builtin_define_fixed_point_constants ("SA", "", sa_type_node); 1027 builtin_define_fixed_point_constants ("DA", "", da_type_node); 1028 builtin_define_fixed_point_constants ("TA", "", ta_type_node); 1029 builtin_define_fixed_point_constants ("UHA", "", uha_type_node); 1030 builtin_define_fixed_point_constants ("USA", "", usa_type_node); 1031 builtin_define_fixed_point_constants ("UDA", "", uda_type_node); 1032 builtin_define_fixed_point_constants ("UTA", "", uta_type_node); 1033 } 1034 1035 /* For libgcc-internal use only. */ 1036 if (flag_building_libgcc) 1037 { 1038 /* Properties of floating-point modes for libgcc2.c. */ 1039 for (machine_mode mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); 1040 mode != VOIDmode; 1041 mode = GET_MODE_WIDER_MODE (mode)) 1042 { 1043 const char *name = GET_MODE_NAME (mode); 1044 char *macro_name 1045 = (char *) alloca (strlen (name) 1046 + sizeof ("__LIBGCC__MANT_DIG__")); 1047 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name); 1048 builtin_define_with_int_value (macro_name, 1049 REAL_MODE_FORMAT (mode)->p); 1050 if (!targetm.scalar_mode_supported_p (mode) 1051 || !targetm.libgcc_floating_mode_supported_p (mode)) 1052 continue; 1053 macro_name = (char *) alloca (strlen (name) 1054 + sizeof ("__LIBGCC_HAS__MODE__")); 1055 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name); 1056 cpp_define (pfile, macro_name); 1057 macro_name = (char *) alloca (strlen (name) 1058 + sizeof ("__LIBGCC__FUNC_EXT__")); 1059 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name); 1060 const char *suffix; 1061 if (mode == TYPE_MODE (double_type_node)) 1062 suffix = ""; 1063 else if (mode == TYPE_MODE (float_type_node)) 1064 suffix = "f"; 1065 else if (mode == TYPE_MODE (long_double_type_node)) 1066 suffix = "l"; 1067 /* ??? The following assumes the built-in functions (defined 1068 in target-specific code) match the suffixes used for 1069 constants. Because in fact such functions are not 1070 defined for the 'w' suffix, 'l' is used there 1071 instead. */ 1072 else if (mode == targetm.c.mode_for_suffix ('q')) 1073 suffix = "q"; 1074 else if (mode == targetm.c.mode_for_suffix ('w')) 1075 suffix = "l"; 1076 else 1077 gcc_unreachable (); 1078 builtin_define_with_value (macro_name, suffix, 0); 1079 bool excess_precision = false; 1080 if (TARGET_FLT_EVAL_METHOD != 0 1081 && mode != TYPE_MODE (long_double_type_node) 1082 && (mode == TYPE_MODE (float_type_node) 1083 || mode == TYPE_MODE (double_type_node))) 1084 switch (TARGET_FLT_EVAL_METHOD) 1085 { 1086 case -1: 1087 case 2: 1088 excess_precision = true; 1089 break; 1090 1091 case 1: 1092 excess_precision = mode == TYPE_MODE (float_type_node); 1093 break; 1094 1095 default: 1096 gcc_unreachable (); 1097 } 1098 macro_name = (char *) alloca (strlen (name) 1099 + sizeof ("__LIBGCC__EXCESS_" 1100 "PRECISION__")); 1101 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name); 1102 builtin_define_with_int_value (macro_name, excess_precision); 1103 } 1104 1105 /* For libgcc crtstuff.c and libgcc2.c. */ 1106 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__", 1107 EH_TABLES_CAN_BE_READ_ONLY); 1108 #ifdef EH_FRAME_SECTION_NAME 1109 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__", 1110 EH_FRAME_SECTION_NAME, 1); 1111 #endif 1112 #ifdef JCR_SECTION_NAME 1113 builtin_define_with_value ("__LIBGCC_JCR_SECTION_NAME__", 1114 JCR_SECTION_NAME, 1); 1115 #endif 1116 #ifdef CTORS_SECTION_ASM_OP 1117 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__", 1118 CTORS_SECTION_ASM_OP, 1); 1119 #endif 1120 #ifdef DTORS_SECTION_ASM_OP 1121 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__", 1122 DTORS_SECTION_ASM_OP, 1); 1123 #endif 1124 #ifdef TEXT_SECTION_ASM_OP 1125 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__", 1126 TEXT_SECTION_ASM_OP, 1); 1127 #endif 1128 #ifdef INIT_SECTION_ASM_OP 1129 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__", 1130 INIT_SECTION_ASM_OP, 1); 1131 #endif 1132 #ifdef INIT_ARRAY_SECTION_ASM_OP 1133 /* Despite the name of this target macro, the expansion is not 1134 actually used, and may be empty rather than a string 1135 constant. */ 1136 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__"); 1137 #endif 1138 1139 /* For libgcc enable-execute-stack.c. */ 1140 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__", 1141 TRAMPOLINE_SIZE); 1142 1143 /* For libgcc generic-morestack.c and unwinder code. */ 1144 #ifdef STACK_GROWS_DOWNWARD 1145 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__"); 1146 #endif 1147 1148 /* For libgcc unwinder code. */ 1149 #ifdef DONT_USE_BUILTIN_SETJMP 1150 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__"); 1151 #endif 1152 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN 1153 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__", 1154 DWARF_ALT_FRAME_RETURN_COLUMN); 1155 #endif 1156 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__", 1157 DWARF_FRAME_REGISTERS); 1158 #ifdef EH_RETURN_STACKADJ_RTX 1159 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__"); 1160 #endif 1161 #ifdef JMP_BUF_SIZE 1162 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__", 1163 JMP_BUF_SIZE); 1164 #endif 1165 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__", 1166 STACK_POINTER_REGNUM); 1167 1168 /* For libgcov. */ 1169 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__", 1170 TARGET_VTABLE_USES_DESCRIPTORS); 1171 } 1172 1173 /* For use in assembly language. */ 1174 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); 1175 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); 1176 1177 /* Misc. */ 1178 if (flag_gnu89_inline) 1179 cpp_define (pfile, "__GNUC_GNU_INLINE__"); 1180 else 1181 cpp_define (pfile, "__GNUC_STDC_INLINE__"); 1182 1183 if (flag_no_inline) 1184 cpp_define (pfile, "__NO_INLINE__"); 1185 1186 if (flag_iso) 1187 cpp_define (pfile, "__STRICT_ANSI__"); 1188 1189 if (!flag_signed_char) 1190 cpp_define (pfile, "__CHAR_UNSIGNED__"); 1191 1192 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) 1193 cpp_define (pfile, "__WCHAR_UNSIGNED__"); 1194 1195 cpp_atomic_builtins (pfile); 1196 1197 #ifdef DWARF2_UNWIND_INFO 1198 if (dwarf2out_do_cfi_asm ()) 1199 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); 1200 #endif 1201 1202 /* Make the choice of ObjC runtime visible to source code. */ 1203 if (c_dialect_objc () && flag_next_runtime) 1204 cpp_define (pfile, "__NEXT_RUNTIME__"); 1205 1206 /* Show the availability of some target pragmas. */ 1207 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); 1208 1209 /* Make the choice of the stack protector runtime visible to source code. 1210 The macro names and values here were chosen for compatibility with an 1211 earlier implementation, i.e. ProPolice. */ 1212 if (flag_stack_protect == 4) 1213 cpp_define (pfile, "__SSP_EXPLICIT__=4"); 1214 if (flag_stack_protect == 3) 1215 cpp_define (pfile, "__SSP_STRONG__=3"); 1216 if (flag_stack_protect == 2) 1217 cpp_define (pfile, "__SSP_ALL__=2"); 1218 else if (flag_stack_protect == 1) 1219 cpp_define (pfile, "__SSP__=1"); 1220 1221 if (flag_openacc) 1222 cpp_define (pfile, "_OPENACC=201306"); 1223 1224 if (flag_openmp) 1225 cpp_define (pfile, "_OPENMP=201307"); 1226 1227 for (i = 0; i < NUM_INT_N_ENTS; i ++) 1228 if (int_n_enabled_p[i]) 1229 { 1230 char buf[15+20]; 1231 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize); 1232 builtin_define_type_sizeof (buf, 1233 int_n_trees[i].signed_type); 1234 } 1235 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); 1236 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); 1237 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", 1238 unsigned_ptrdiff_type_node); 1239 1240 /* A straightforward target hook doesn't work, because of problems 1241 linking that hook's body when part of non-C front ends. */ 1242 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) 1243 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) 1244 # define builtin_define(TXT) cpp_define (pfile, TXT) 1245 # define builtin_assert(TXT) cpp_assert (pfile, TXT) 1246 TARGET_CPU_CPP_BUILTINS (); 1247 TARGET_OS_CPP_BUILTINS (); 1248 TARGET_OBJFMT_CPP_BUILTINS (); 1249 1250 /* Support the __declspec keyword by turning them into attributes. 1251 Note that the current way we do this may result in a collision 1252 with predefined attributes later on. This can be solved by using 1253 one attribute, say __declspec__, and passing args to it. The 1254 problem with that approach is that args are not accumulated: each 1255 new appearance would clobber any existing args. */ 1256 if (TARGET_DECLSPEC) 1257 builtin_define ("__declspec(x)=__attribute__((x))"); 1258 1259 /* If decimal floating point is supported, tell the user if the 1260 alternate format (BID) is used instead of the standard (DPD) 1261 format. */ 1262 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) 1263 cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); 1264 } 1265 1266 /* Pass an object-like macro. If it doesn't lie in the user's 1267 namespace, defines it unconditionally. Otherwise define a version 1268 with two leading underscores, and another version with two leading 1269 and trailing underscores, and define the original only if an ISO 1270 standard was not nominated. 1271 1272 e.g. passing "unix" defines "__unix", "__unix__" and possibly 1273 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly 1274 "_mips". */ 1275 void 1276 builtin_define_std (const char *macro) 1277 { 1278 size_t len = strlen (macro); 1279 char *buff = (char *) alloca (len + 5); 1280 char *p = buff + 2; 1281 char *q = p + len; 1282 1283 /* prepend __ (or maybe just _) if in user's namespace. */ 1284 memcpy (p, macro, len + 1); 1285 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) 1286 { 1287 if (*p != '_') 1288 *--p = '_'; 1289 if (p[1] != '_') 1290 *--p = '_'; 1291 } 1292 cpp_define (parse_in, p); 1293 1294 /* If it was in user's namespace... */ 1295 if (p != buff + 2) 1296 { 1297 /* Define the macro with leading and following __. */ 1298 if (q[-1] != '_') 1299 *q++ = '_'; 1300 if (q[-2] != '_') 1301 *q++ = '_'; 1302 *q = '\0'; 1303 cpp_define (parse_in, p); 1304 1305 /* Finally, define the original macro if permitted. */ 1306 if (!flag_iso) 1307 cpp_define (parse_in, macro); 1308 } 1309 } 1310 1311 /* Pass an object-like macro and a value to define it to. The third 1312 parameter says whether or not to turn the value into a string 1313 constant. */ 1314 void 1315 builtin_define_with_value (const char *macro, const char *expansion, int is_str) 1316 { 1317 char *buf; 1318 size_t mlen = strlen (macro); 1319 size_t elen = strlen (expansion); 1320 size_t extra = 2; /* space for an = and a NUL */ 1321 1322 if (is_str) 1323 { 1324 char *quoted_expansion = (char *) alloca (elen * 4 + 1); 1325 const char *p; 1326 char *q; 1327 extra += 2; /* space for two quote marks */ 1328 for (p = expansion, q = quoted_expansion; *p; p++) 1329 { 1330 switch (*p) 1331 { 1332 case '\n': 1333 *q++ = '\\'; 1334 *q++ = 'n'; 1335 break; 1336 1337 case '\t': 1338 *q++ = '\\'; 1339 *q++ = 't'; 1340 break; 1341 1342 case '\\': 1343 *q++ = '\\'; 1344 *q++ = '\\'; 1345 break; 1346 1347 case '"': 1348 *q++ = '\\'; 1349 *q++ = '"'; 1350 break; 1351 1352 default: 1353 if (ISPRINT ((unsigned char) *p)) 1354 *q++ = *p; 1355 else 1356 { 1357 sprintf (q, "\\%03o", (unsigned char) *p); 1358 q += 4; 1359 } 1360 } 1361 } 1362 *q = '\0'; 1363 expansion = quoted_expansion; 1364 elen = q - expansion; 1365 } 1366 1367 buf = (char *) alloca (mlen + elen + extra); 1368 if (is_str) 1369 sprintf (buf, "%s=\"%s\"", macro, expansion); 1370 else 1371 sprintf (buf, "%s=%s", macro, expansion); 1372 1373 cpp_define (parse_in, buf); 1374 } 1375 1376 1377 /* Pass an object-like macro and an integer value to define it to. */ 1378 static void 1379 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 1380 { 1381 char *buf; 1382 size_t mlen = strlen (macro); 1383 size_t vlen = 18; 1384 size_t extra = 2; /* space for = and NUL. */ 1385 1386 buf = (char *) alloca (mlen + vlen + extra); 1387 memcpy (buf, macro, mlen); 1388 buf[mlen] = '='; 1389 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); 1390 1391 cpp_define (parse_in, buf); 1392 } 1393 1394 /* builtin_define_with_hex_fp_value is very expensive, so the following 1395 array and function allows it to be done lazily when __DBL_MAX__ 1396 etc. is first used. */ 1397 1398 struct GTY(()) lazy_hex_fp_value_struct 1399 { 1400 const char *hex_str; 1401 cpp_macro *macro; 1402 machine_mode mode; 1403 int digits; 1404 const char *fp_suffix; 1405 }; 1406 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12]; 1407 static GTY(()) int lazy_hex_fp_value_count; 1408 1409 static bool 1410 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED, 1411 cpp_hashnode *node) 1412 { 1413 REAL_VALUE_TYPE real; 1414 char dec_str[64], buf1[256]; 1415 unsigned int idx; 1416 if (node->value.builtin < BT_FIRST_USER 1417 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count) 1418 return false; 1419 1420 idx = node->value.builtin - BT_FIRST_USER; 1421 real_from_string (&real, lazy_hex_fp_values[idx].hex_str); 1422 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), 1423 lazy_hex_fp_values[idx].digits, 0, 1424 lazy_hex_fp_values[idx].mode); 1425 1426 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix); 1427 node->flags &= ~(NODE_BUILTIN | NODE_USED); 1428 node->value.macro = lazy_hex_fp_values[idx].macro; 1429 for (idx = 0; idx < node->value.macro->count; idx++) 1430 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER) 1431 break; 1432 gcc_assert (idx < node->value.macro->count); 1433 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1); 1434 node->value.macro->exp.tokens[idx].val.str.text 1435 = (const unsigned char *) ggc_strdup (buf1); 1436 return true; 1437 } 1438 1439 /* Pass an object-like macro a hexadecimal floating-point value. */ 1440 static void 1441 builtin_define_with_hex_fp_value (const char *macro, 1442 tree type, int digits, 1443 const char *hex_str, 1444 const char *fp_suffix, 1445 const char *fp_cast) 1446 { 1447 REAL_VALUE_TYPE real; 1448 char dec_str[64], buf1[256], buf2[256]; 1449 1450 /* This is very expensive, so if possible expand them lazily. */ 1451 if (lazy_hex_fp_value_count < 12 1452 && flag_dump_macros == 0 1453 && !cpp_get_options (parse_in)->traditional) 1454 { 1455 struct cpp_hashnode *node; 1456 if (lazy_hex_fp_value_count == 0) 1457 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value; 1458 sprintf (buf2, fp_cast, "1.1"); 1459 sprintf (buf1, "%s=%s", macro, buf2); 1460 cpp_define (parse_in, buf1); 1461 node = C_CPP_HASHNODE (get_identifier (macro)); 1462 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str 1463 = ggc_strdup (hex_str); 1464 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type); 1465 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits; 1466 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix; 1467 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro; 1468 node->flags |= NODE_BUILTIN; 1469 node->value.builtin 1470 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count); 1471 lazy_hex_fp_value_count++; 1472 return; 1473 } 1474 1475 /* Hex values are really cool and convenient, except that they're 1476 not supported in strict ISO C90 mode. First, the "p-" sequence 1477 is not valid as part of a preprocessor number. Second, we get a 1478 pedwarn from the preprocessor, which has no context, so we can't 1479 suppress the warning with __extension__. 1480 1481 So instead what we do is construct the number in hex (because 1482 it's easy to get the exact correct value), parse it as a real, 1483 then print it back out as decimal. */ 1484 1485 real_from_string (&real, hex_str); 1486 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0, 1487 TYPE_MODE (type)); 1488 1489 /* Assemble the macro in the following fashion 1490 macro = fp_cast [dec_str fp_suffix] */ 1491 sprintf (buf1, "%s%s", dec_str, fp_suffix); 1492 sprintf (buf2, fp_cast, buf1); 1493 sprintf (buf1, "%s=%s", macro, buf2); 1494 1495 cpp_define (parse_in, buf1); 1496 } 1497 1498 /* Return a string constant for the suffix for a value of type TYPE 1499 promoted according to the integer promotions. The type must be one 1500 of the standard integer type nodes. */ 1501 1502 static const char * 1503 type_suffix (tree type) 1504 { 1505 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; 1506 int unsigned_suffix; 1507 int is_long; 1508 int tp = TYPE_PRECISION (type); 1509 1510 if (type == long_long_integer_type_node 1511 || type == long_long_unsigned_type_node 1512 || tp > TYPE_PRECISION (long_integer_type_node)) 1513 is_long = 2; 1514 else if (type == long_integer_type_node 1515 || type == long_unsigned_type_node 1516 || tp > TYPE_PRECISION (integer_type_node)) 1517 is_long = 1; 1518 else if (type == integer_type_node 1519 || type == unsigned_type_node 1520 || type == short_integer_type_node 1521 || type == short_unsigned_type_node 1522 || type == signed_char_type_node 1523 || type == unsigned_char_type_node 1524 /* ??? "char" is not a signed or unsigned integer type and 1525 so is not permitted for the standard typedefs, but some 1526 systems use it anyway. */ 1527 || type == char_type_node) 1528 is_long = 0; 1529 else 1530 gcc_unreachable (); 1531 1532 unsigned_suffix = TYPE_UNSIGNED (type); 1533 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) 1534 unsigned_suffix = 0; 1535 return suffixes[is_long * 2 + unsigned_suffix]; 1536 } 1537 1538 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */ 1539 static void 1540 builtin_define_constants (const char *macro, tree type) 1541 { 1542 const char *suffix; 1543 char *buf; 1544 1545 suffix = type_suffix (type); 1546 1547 if (suffix[0] == 0) 1548 { 1549 buf = (char *) alloca (strlen (macro) + 6); 1550 sprintf (buf, "%s(c)=c", macro); 1551 } 1552 else 1553 { 1554 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1); 1555 sprintf (buf, "%s(c)=c ## %s", macro, suffix); 1556 } 1557 1558 cpp_define (parse_in, buf); 1559 } 1560 1561 /* Define MAX for TYPE based on the precision of the type. */ 1562 1563 static void 1564 builtin_define_type_max (const char *macro, tree type) 1565 { 1566 builtin_define_type_minmax (NULL, macro, type); 1567 } 1568 1569 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal 1570 representation of that value. For example, a COUNT of 10 would 1571 return "0x3ff". */ 1572 1573 static void 1574 print_bits_of_hex (char *buf, int bufsz, int count) 1575 { 1576 gcc_assert (bufsz > 3); 1577 *buf++ = '0'; 1578 *buf++ = 'x'; 1579 bufsz -= 2; 1580 1581 gcc_assert (count > 0); 1582 1583 switch (count % 4) { 1584 case 0: 1585 break; 1586 case 1: 1587 *buf++ = '1'; 1588 bufsz --; 1589 count -= 1; 1590 break; 1591 case 2: 1592 *buf++ = '3'; 1593 bufsz --; 1594 count -= 2; 1595 break; 1596 case 3: 1597 *buf++ = '7'; 1598 bufsz --; 1599 count -= 3; 1600 break; 1601 } 1602 while (count >= 4) 1603 { 1604 gcc_assert (bufsz > 1); 1605 *buf++ = 'f'; 1606 bufsz --; 1607 count -= 4; 1608 } 1609 gcc_assert (bufsz > 0); 1610 *buf++ = 0; 1611 } 1612 1613 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the 1614 precision of the type. */ 1615 1616 static void 1617 builtin_define_type_minmax (const char *min_macro, const char *max_macro, 1618 tree type) 1619 { 1620 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4) 1621 char value[PBOH_SZ]; 1622 1623 const char *suffix; 1624 char *buf; 1625 int bits; 1626 1627 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1); 1628 1629 print_bits_of_hex (value, PBOH_SZ, bits); 1630 1631 suffix = type_suffix (type); 1632 1633 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value) 1634 + strlen (suffix) + 1); 1635 sprintf (buf, "%s=%s%s", max_macro, value, suffix); 1636 1637 cpp_define (parse_in, buf); 1638 1639 if (min_macro) 1640 { 1641 if (TYPE_UNSIGNED (type)) 1642 { 1643 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1); 1644 sprintf (buf, "%s=0%s", min_macro, suffix); 1645 } 1646 else 1647 { 1648 buf = (char *) alloca (strlen (min_macro) + 3 1649 + strlen (max_macro) + 6); 1650 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro); 1651 } 1652 cpp_define (parse_in, buf); 1653 } 1654 } 1655 1656 #include "gt-c-family-c-cppbuiltin.h" 1657