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