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