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 cpp_define (pfile, "__cpp_template_auto=201606"); 976 cpp_define (pfile, "__cpp_structured_bindings=201606"); 977 cpp_define (pfile, "__cpp_variadic_using=201611"); 978 } 979 if (flag_concepts) 980 cpp_define (pfile, "__cpp_concepts=201507"); 981 if (flag_tm) 982 /* Use a value smaller than the 201505 specified in 983 the TS, since we don't yet support atomic_cancel. */ 984 cpp_define (pfile, "__cpp_transactional_memory=210500"); 985 if (flag_sized_deallocation) 986 cpp_define (pfile, "__cpp_sized_deallocation=201309"); 987 if (aligned_new_threshold) 988 { 989 cpp_define (pfile, "__cpp_aligned_new=201606"); 990 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d", 991 aligned_new_threshold); 992 } 993 if (flag_new_ttp) 994 cpp_define (pfile, "__cpp_template_template_args=201611"); 995 if (flag_threadsafe_statics) 996 cpp_define (pfile, "__cpp_threadsafe_static_init=200806"); 997 } 998 /* Note that we define this for C as well, so that we know if 999 __attribute__((cleanup)) will interface with EH. */ 1000 if (flag_exceptions) 1001 { 1002 cpp_define (pfile, "__EXCEPTIONS"); 1003 if (c_dialect_cxx ()) 1004 cpp_define (pfile, "__cpp_exceptions=199711"); 1005 } 1006 1007 /* Represents the C++ ABI version, always defined so it can be used while 1008 preprocessing C and assembler. */ 1009 if (flag_abi_version == 0) 1010 /* We should have set this to something real in c_common_post_options. */ 1011 gcc_unreachable (); 1012 else if (flag_abi_version == 1) 1013 /* Due to a historical accident, this version had the value 1014 "102". */ 1015 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); 1016 else 1017 /* Newer versions have values 1002, 1003, .... */ 1018 builtin_define_with_int_value ("__GXX_ABI_VERSION", 1019 1000 + flag_abi_version); 1020 1021 /* libgcc needs to know this. */ 1022 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 1023 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); 1024 1025 /* limits.h and stdint.h need to know these. */ 1026 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node); 1027 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node); 1028 builtin_define_type_max ("__INT_MAX__", integer_type_node); 1029 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node); 1030 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node); 1031 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__", 1032 underlying_wchar_type_node); 1033 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node); 1034 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node); 1035 builtin_define_type_max ("__SIZE_MAX__", size_type_node); 1036 1037 /* These are needed for TS 18661-1. */ 1038 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node, 1039 unsigned_char_type_node); 1040 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node, 1041 short_unsigned_type_node); 1042 builtin_define_type_width ("__INT_WIDTH__", integer_type_node, 1043 unsigned_type_node); 1044 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node, 1045 long_unsigned_type_node); 1046 builtin_define_type_width ("__LONG_LONG_WIDTH__", 1047 long_long_integer_type_node, 1048 long_long_unsigned_type_node); 1049 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node, 1050 NULL_TREE); 1051 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE); 1052 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE); 1053 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE); 1054 1055 if (c_dialect_cxx ()) 1056 for (i = 0; i < NUM_INT_N_ENTS; i ++) 1057 if (int_n_enabled_p[i]) 1058 { 1059 char buf[35+20+20]; 1060 1061 /* These are used to configure the C++ library. */ 1062 1063 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE) 1064 { 1065 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize); 1066 cpp_define (parse_in, buf); 1067 1068 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize); 1069 cpp_define (parse_in, buf); 1070 } 1071 } 1072 1073 /* stdint.h and the testsuite need to know these. */ 1074 builtin_define_stdint_macros (); 1075 1076 /* Provide information for library headers to determine whether to 1077 define macros such as __STDC_IEC_559__ and 1078 __STDC_IEC_559_COMPLEX__. */ 1079 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ()); 1080 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX", 1081 cpp_iec_559_complex_value ()); 1082 1083 /* float.h needs these to correctly set FLT_EVAL_METHOD 1084 1085 We define two values: 1086 1087 __FLT_EVAL_METHOD__ 1088 Which, depending on the value given for 1089 -fpermitted-flt-eval-methods, may be limited to only those values 1090 for FLT_EVAL_METHOD defined in C99/C11. 1091 1092 __FLT_EVAL_METHOD_TS_18661_3__ 1093 Which always permits the values for FLT_EVAL_METHOD defined in 1094 ISO/IEC TS 18661-3. */ 1095 builtin_define_with_int_value ("__FLT_EVAL_METHOD__", 1096 c_flt_eval_method (true)); 1097 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__", 1098 c_flt_eval_method (false)); 1099 1100 /* And decfloat.h needs this. */ 1101 builtin_define_with_int_value ("__DEC_EVAL_METHOD__", 1102 TARGET_DEC_EVAL_METHOD); 1103 1104 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node); 1105 /* Cast the double precision constants. This is needed when single 1106 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64 1107 is used. The correct result is computed by the compiler when using 1108 macros that include a cast. We use a different cast for C++ to avoid 1109 problems with -Wold-style-cast. */ 1110 builtin_define_float_constants ("DBL", "L", 1111 (c_dialect_cxx () 1112 ? "double(%s)" 1113 : "((double)%s)"), 1114 "", double_type_node); 1115 builtin_define_float_constants ("LDBL", "L", "%s", "L", 1116 long_double_type_node); 1117 1118 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++) 1119 { 1120 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE) 1121 continue; 1122 char prefix[20], csuffix[20]; 1123 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n, 1124 floatn_nx_types[i].extended ? "X" : ""); 1125 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n, 1126 floatn_nx_types[i].extended ? "x" : ""); 1127 builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s", 1128 csuffix, FLOATN_NX_TYPE_NODE (i)); 1129 } 1130 1131 /* For decfloat.h. */ 1132 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); 1133 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); 1134 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); 1135 1136 /* For fixed-point fibt, ibit, max, min, and epsilon. */ 1137 if (targetm.fixed_point_supported_p ()) 1138 { 1139 builtin_define_fixed_point_constants ("SFRACT", "HR", 1140 short_fract_type_node); 1141 builtin_define_fixed_point_constants ("USFRACT", "UHR", 1142 unsigned_short_fract_type_node); 1143 builtin_define_fixed_point_constants ("FRACT", "R", 1144 fract_type_node); 1145 builtin_define_fixed_point_constants ("UFRACT", "UR", 1146 unsigned_fract_type_node); 1147 builtin_define_fixed_point_constants ("LFRACT", "LR", 1148 long_fract_type_node); 1149 builtin_define_fixed_point_constants ("ULFRACT", "ULR", 1150 unsigned_long_fract_type_node); 1151 builtin_define_fixed_point_constants ("LLFRACT", "LLR", 1152 long_long_fract_type_node); 1153 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", 1154 unsigned_long_long_fract_type_node); 1155 builtin_define_fixed_point_constants ("SACCUM", "HK", 1156 short_accum_type_node); 1157 builtin_define_fixed_point_constants ("USACCUM", "UHK", 1158 unsigned_short_accum_type_node); 1159 builtin_define_fixed_point_constants ("ACCUM", "K", 1160 accum_type_node); 1161 builtin_define_fixed_point_constants ("UACCUM", "UK", 1162 unsigned_accum_type_node); 1163 builtin_define_fixed_point_constants ("LACCUM", "LK", 1164 long_accum_type_node); 1165 builtin_define_fixed_point_constants ("ULACCUM", "ULK", 1166 unsigned_long_accum_type_node); 1167 builtin_define_fixed_point_constants ("LLACCUM", "LLK", 1168 long_long_accum_type_node); 1169 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", 1170 unsigned_long_long_accum_type_node); 1171 1172 builtin_define_fixed_point_constants ("QQ", "", qq_type_node); 1173 builtin_define_fixed_point_constants ("HQ", "", hq_type_node); 1174 builtin_define_fixed_point_constants ("SQ", "", sq_type_node); 1175 builtin_define_fixed_point_constants ("DQ", "", dq_type_node); 1176 builtin_define_fixed_point_constants ("TQ", "", tq_type_node); 1177 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); 1178 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); 1179 builtin_define_fixed_point_constants ("USQ", "", usq_type_node); 1180 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); 1181 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); 1182 builtin_define_fixed_point_constants ("HA", "", ha_type_node); 1183 builtin_define_fixed_point_constants ("SA", "", sa_type_node); 1184 builtin_define_fixed_point_constants ("DA", "", da_type_node); 1185 builtin_define_fixed_point_constants ("TA", "", ta_type_node); 1186 builtin_define_fixed_point_constants ("UHA", "", uha_type_node); 1187 builtin_define_fixed_point_constants ("USA", "", usa_type_node); 1188 builtin_define_fixed_point_constants ("UDA", "", uda_type_node); 1189 builtin_define_fixed_point_constants ("UTA", "", uta_type_node); 1190 } 1191 1192 /* For libgcc-internal use only. */ 1193 if (flag_building_libgcc) 1194 { 1195 /* Properties of floating-point modes for libgcc2.c. */ 1196 opt_scalar_float_mode mode_iter; 1197 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT) 1198 { 1199 scalar_float_mode mode = mode_iter.require (); 1200 const char *name = GET_MODE_NAME (mode); 1201 char *macro_name 1202 = (char *) alloca (strlen (name) 1203 + sizeof ("__LIBGCC__MANT_DIG__")); 1204 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name); 1205 builtin_define_with_int_value (macro_name, 1206 REAL_MODE_FORMAT (mode)->p); 1207 if (!targetm.scalar_mode_supported_p (mode) 1208 || !targetm.libgcc_floating_mode_supported_p (mode)) 1209 continue; 1210 macro_name = (char *) alloca (strlen (name) 1211 + sizeof ("__LIBGCC_HAS__MODE__")); 1212 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name); 1213 cpp_define (pfile, macro_name); 1214 macro_name = (char *) alloca (strlen (name) 1215 + sizeof ("__LIBGCC__FUNC_EXT__")); 1216 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name); 1217 char suffix[20] = ""; 1218 if (mode == TYPE_MODE (double_type_node)) 1219 ; /* Empty suffix correct. */ 1220 else if (mode == TYPE_MODE (float_type_node)) 1221 suffix[0] = 'f'; 1222 else if (mode == TYPE_MODE (long_double_type_node)) 1223 suffix[0] = 'l'; 1224 else 1225 { 1226 bool found_suffix = false; 1227 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++) 1228 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE 1229 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i))) 1230 { 1231 sprintf (suffix, "f%d%s", floatn_nx_types[i].n, 1232 floatn_nx_types[i].extended ? "x" : ""); 1233 found_suffix = true; 1234 break; 1235 } 1236 gcc_assert (found_suffix); 1237 } 1238 builtin_define_with_value (macro_name, suffix, 0); 1239 1240 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about 1241 eliminating excess precision from results assigned to 1242 variables - meaning it should be about the implicit excess 1243 precision only. */ 1244 bool excess_precision = false; 1245 machine_mode float16_type_mode = (float16_type_node 1246 ? TYPE_MODE (float16_type_node) 1247 : VOIDmode); 1248 switch (targetm.c.excess_precision 1249 (EXCESS_PRECISION_TYPE_IMPLICIT)) 1250 { 1251 case FLT_EVAL_METHOD_UNPREDICTABLE: 1252 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE: 1253 excess_precision = (mode == float16_type_mode 1254 || mode == TYPE_MODE (float_type_node) 1255 || mode == TYPE_MODE (double_type_node)); 1256 break; 1257 1258 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE: 1259 excess_precision = (mode == float16_type_mode 1260 || mode == TYPE_MODE (float_type_node)); 1261 break; 1262 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT: 1263 excess_precision = mode == float16_type_mode; 1264 break; 1265 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16: 1266 excess_precision = false; 1267 break; 1268 default: 1269 gcc_unreachable (); 1270 } 1271 macro_name = (char *) alloca (strlen (name) 1272 + sizeof ("__LIBGCC__EXCESS_" 1273 "PRECISION__")); 1274 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name); 1275 builtin_define_with_int_value (macro_name, excess_precision); 1276 } 1277 1278 /* For libgcc crtstuff.c and libgcc2.c. */ 1279 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__", 1280 EH_TABLES_CAN_BE_READ_ONLY); 1281 #ifdef EH_FRAME_SECTION_NAME 1282 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__", 1283 EH_FRAME_SECTION_NAME, 1); 1284 #endif 1285 #ifdef CTORS_SECTION_ASM_OP 1286 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__", 1287 CTORS_SECTION_ASM_OP, 1); 1288 #endif 1289 #ifdef DTORS_SECTION_ASM_OP 1290 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__", 1291 DTORS_SECTION_ASM_OP, 1); 1292 #endif 1293 #ifdef TEXT_SECTION_ASM_OP 1294 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__", 1295 TEXT_SECTION_ASM_OP, 1); 1296 #endif 1297 #ifdef INIT_SECTION_ASM_OP 1298 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__", 1299 INIT_SECTION_ASM_OP, 1); 1300 #endif 1301 #ifdef INIT_ARRAY_SECTION_ASM_OP 1302 /* Despite the name of this target macro, the expansion is not 1303 actually used, and may be empty rather than a string 1304 constant. */ 1305 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__"); 1306 #endif 1307 1308 /* For libgcc enable-execute-stack.c. */ 1309 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__", 1310 TRAMPOLINE_SIZE); 1311 1312 /* For libgcc generic-morestack.c and unwinder code. */ 1313 if (STACK_GROWS_DOWNWARD) 1314 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__"); 1315 1316 /* For libgcc unwinder code. */ 1317 #ifdef DONT_USE_BUILTIN_SETJMP 1318 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__"); 1319 #endif 1320 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN 1321 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__", 1322 DWARF_ALT_FRAME_RETURN_COLUMN); 1323 #endif 1324 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__", 1325 DWARF_FRAME_REGISTERS); 1326 #ifdef EH_RETURN_STACKADJ_RTX 1327 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__"); 1328 #endif 1329 #ifdef JMP_BUF_SIZE 1330 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__", 1331 JMP_BUF_SIZE); 1332 #endif 1333 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__", 1334 STACK_POINTER_REGNUM); 1335 1336 /* For libgcov. */ 1337 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__", 1338 TARGET_VTABLE_USES_DESCRIPTORS); 1339 } 1340 1341 /* For use in assembly language. */ 1342 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); 1343 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); 1344 1345 /* Misc. */ 1346 if (flag_gnu89_inline) 1347 cpp_define (pfile, "__GNUC_GNU_INLINE__"); 1348 else 1349 cpp_define (pfile, "__GNUC_STDC_INLINE__"); 1350 1351 if (flag_no_inline) 1352 cpp_define (pfile, "__NO_INLINE__"); 1353 1354 if (flag_iso) 1355 cpp_define (pfile, "__STRICT_ANSI__"); 1356 1357 if (!flag_signed_char) 1358 cpp_define (pfile, "__CHAR_UNSIGNED__"); 1359 1360 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) 1361 cpp_define (pfile, "__WCHAR_UNSIGNED__"); 1362 1363 cpp_atomic_builtins (pfile); 1364 1365 #ifdef DWARF2_UNWIND_INFO 1366 if (dwarf2out_do_cfi_asm ()) 1367 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); 1368 #endif 1369 1370 /* Make the choice of ObjC runtime visible to source code. */ 1371 if (c_dialect_objc () && flag_next_runtime) 1372 cpp_define (pfile, "__NEXT_RUNTIME__"); 1373 1374 /* Show the availability of some target pragmas. */ 1375 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); 1376 1377 /* Make the choice of the stack protector runtime visible to source code. 1378 The macro names and values here were chosen for compatibility with an 1379 earlier implementation, i.e. ProPolice. */ 1380 if (flag_stack_protect == 4) 1381 cpp_define (pfile, "__SSP_EXPLICIT__=4"); 1382 if (flag_stack_protect == 3) 1383 cpp_define (pfile, "__SSP_STRONG__=3"); 1384 if (flag_stack_protect == 2) 1385 cpp_define (pfile, "__SSP_ALL__=2"); 1386 else if (flag_stack_protect == 1) 1387 cpp_define (pfile, "__SSP__=1"); 1388 1389 if (flag_openacc) 1390 cpp_define (pfile, "_OPENACC=201306"); 1391 1392 if (flag_openmp) 1393 cpp_define (pfile, "_OPENMP=201511"); 1394 1395 for (i = 0; i < NUM_INT_N_ENTS; i ++) 1396 if (int_n_enabled_p[i]) 1397 { 1398 char buf[15+20]; 1399 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize); 1400 builtin_define_type_sizeof (buf, 1401 int_n_trees[i].signed_type); 1402 } 1403 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); 1404 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); 1405 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", 1406 unsigned_ptrdiff_type_node); 1407 1408 /* A straightforward target hook doesn't work, because of problems 1409 linking that hook's body when part of non-C front ends. */ 1410 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) 1411 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) 1412 # define builtin_define(TXT) cpp_define (pfile, TXT) 1413 # define builtin_assert(TXT) cpp_assert (pfile, TXT) 1414 TARGET_CPU_CPP_BUILTINS (); 1415 TARGET_OS_CPP_BUILTINS (); 1416 TARGET_OBJFMT_CPP_BUILTINS (); 1417 1418 /* Support the __declspec keyword by turning them into attributes. 1419 Note that the current way we do this may result in a collision 1420 with predefined attributes later on. This can be solved by using 1421 one attribute, say __declspec__, and passing args to it. The 1422 problem with that approach is that args are not accumulated: each 1423 new appearance would clobber any existing args. */ 1424 if (TARGET_DECLSPEC) 1425 builtin_define ("__declspec(x)=__attribute__((x))"); 1426 1427 /* If decimal floating point is supported, tell the user if the 1428 alternate format (BID) is used instead of the standard (DPD) 1429 format. */ 1430 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) 1431 cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); 1432 } 1433 1434 /* Pass an object-like macro. If it doesn't lie in the user's 1435 namespace, defines it unconditionally. Otherwise define a version 1436 with two leading underscores, and another version with two leading 1437 and trailing underscores, and define the original only if an ISO 1438 standard was not nominated. 1439 1440 e.g. passing "unix" defines "__unix", "__unix__" and possibly 1441 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly 1442 "_mips". */ 1443 void 1444 builtin_define_std (const char *macro) 1445 { 1446 size_t len = strlen (macro); 1447 char *buff = (char *) alloca (len + 5); 1448 char *p = buff + 2; 1449 char *q = p + len; 1450 1451 /* prepend __ (or maybe just _) if in user's namespace. */ 1452 memcpy (p, macro, len + 1); 1453 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) 1454 { 1455 if (*p != '_') 1456 *--p = '_'; 1457 if (p[1] != '_') 1458 *--p = '_'; 1459 } 1460 cpp_define (parse_in, p); 1461 1462 /* If it was in user's namespace... */ 1463 if (p != buff + 2) 1464 { 1465 /* Define the macro with leading and following __. */ 1466 if (q[-1] != '_') 1467 *q++ = '_'; 1468 if (q[-2] != '_') 1469 *q++ = '_'; 1470 *q = '\0'; 1471 cpp_define (parse_in, p); 1472 1473 /* Finally, define the original macro if permitted. */ 1474 if (!flag_iso) 1475 cpp_define (parse_in, macro); 1476 } 1477 } 1478 1479 /* Pass an object-like macro and a value to define it to. The third 1480 parameter says whether or not to turn the value into a string 1481 constant. */ 1482 void 1483 builtin_define_with_value (const char *macro, const char *expansion, int is_str) 1484 { 1485 char *buf; 1486 size_t mlen = strlen (macro); 1487 size_t elen = strlen (expansion); 1488 size_t extra = 2; /* space for an = and a NUL */ 1489 1490 if (is_str) 1491 { 1492 char *quoted_expansion = (char *) alloca (elen * 4 + 1); 1493 const char *p; 1494 char *q; 1495 extra += 2; /* space for two quote marks */ 1496 for (p = expansion, q = quoted_expansion; *p; p++) 1497 { 1498 switch (*p) 1499 { 1500 case '\n': 1501 *q++ = '\\'; 1502 *q++ = 'n'; 1503 break; 1504 1505 case '\t': 1506 *q++ = '\\'; 1507 *q++ = 't'; 1508 break; 1509 1510 case '\\': 1511 *q++ = '\\'; 1512 *q++ = '\\'; 1513 break; 1514 1515 case '"': 1516 *q++ = '\\'; 1517 *q++ = '"'; 1518 break; 1519 1520 default: 1521 if (ISPRINT ((unsigned char) *p)) 1522 *q++ = *p; 1523 else 1524 { 1525 sprintf (q, "\\%03o", (unsigned char) *p); 1526 q += 4; 1527 } 1528 } 1529 } 1530 *q = '\0'; 1531 expansion = quoted_expansion; 1532 elen = q - expansion; 1533 } 1534 1535 buf = (char *) alloca (mlen + elen + extra); 1536 if (is_str) 1537 sprintf (buf, "%s=\"%s\"", macro, expansion); 1538 else 1539 sprintf (buf, "%s=%s", macro, expansion); 1540 1541 cpp_define (parse_in, buf); 1542 } 1543 1544 1545 /* Pass an object-like macro and an integer value to define it to. */ 1546 void 1547 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 1548 { 1549 char *buf; 1550 size_t mlen = strlen (macro); 1551 size_t vlen = 18; 1552 size_t extra = 2; /* space for = and NUL. */ 1553 1554 buf = (char *) alloca (mlen + vlen + extra); 1555 memcpy (buf, macro, mlen); 1556 buf[mlen] = '='; 1557 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); 1558 1559 cpp_define (parse_in, buf); 1560 } 1561 1562 /* builtin_define_with_hex_fp_value is very expensive, so the following 1563 array and function allows it to be done lazily when __DBL_MAX__ 1564 etc. is first used. */ 1565 1566 struct GTY(()) lazy_hex_fp_value_struct 1567 { 1568 const char *hex_str; 1569 cpp_macro *macro; 1570 machine_mode mode; 1571 int digits; 1572 const char *fp_suffix; 1573 }; 1574 /* Number of the expensive to compute macros we should evaluate lazily. 1575 Each builtin_define_float_constants invocation calls 1576 builtin_define_with_hex_fp_value 4 times and builtin_define_float_constants 1577 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for 1578 FLTNN*. */ 1579 #define LAZY_HEX_FP_VALUES_CNT (4 * (3 + NUM_FLOATN_NX_TYPES)) 1580 static GTY(()) struct lazy_hex_fp_value_struct 1581 lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT]; 1582 static GTY(()) int lazy_hex_fp_value_count; 1583 1584 static bool 1585 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED, 1586 cpp_hashnode *node) 1587 { 1588 REAL_VALUE_TYPE real; 1589 char dec_str[64], buf1[256]; 1590 unsigned int idx; 1591 if (node->value.builtin < BT_FIRST_USER 1592 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count) 1593 return false; 1594 1595 idx = node->value.builtin - BT_FIRST_USER; 1596 real_from_string (&real, lazy_hex_fp_values[idx].hex_str); 1597 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), 1598 lazy_hex_fp_values[idx].digits, 0, 1599 lazy_hex_fp_values[idx].mode); 1600 1601 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix); 1602 node->flags &= ~(NODE_BUILTIN | NODE_USED); 1603 node->value.macro = lazy_hex_fp_values[idx].macro; 1604 for (idx = 0; idx < node->value.macro->count; idx++) 1605 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER) 1606 break; 1607 gcc_assert (idx < node->value.macro->count); 1608 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1); 1609 node->value.macro->exp.tokens[idx].val.str.text 1610 = (const unsigned char *) ggc_strdup (buf1); 1611 return true; 1612 } 1613 1614 /* Pass an object-like macro a hexadecimal floating-point value. */ 1615 static void 1616 builtin_define_with_hex_fp_value (const char *macro, 1617 tree type, int digits, 1618 const char *hex_str, 1619 const char *fp_suffix, 1620 const char *fp_cast) 1621 { 1622 REAL_VALUE_TYPE real; 1623 char dec_str[64], buf[256], buf1[128], buf2[64]; 1624 1625 /* This is very expensive, so if possible expand them lazily. */ 1626 if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT 1627 && flag_dump_macros == 0 1628 && !cpp_get_options (parse_in)->traditional) 1629 { 1630 struct cpp_hashnode *node; 1631 if (lazy_hex_fp_value_count == 0) 1632 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value; 1633 sprintf (buf2, fp_cast, "1.1"); 1634 sprintf (buf1, "%s=%s", macro, buf2); 1635 cpp_define (parse_in, buf1); 1636 node = C_CPP_HASHNODE (get_identifier (macro)); 1637 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str 1638 = ggc_strdup (hex_str); 1639 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type); 1640 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits; 1641 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix; 1642 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro; 1643 node->flags |= NODE_BUILTIN; 1644 node->value.builtin 1645 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count); 1646 lazy_hex_fp_value_count++; 1647 return; 1648 } 1649 1650 /* Hex values are really cool and convenient, except that they're 1651 not supported in strict ISO C90 mode. First, the "p-" sequence 1652 is not valid as part of a preprocessor number. Second, we get a 1653 pedwarn from the preprocessor, which has no context, so we can't 1654 suppress the warning with __extension__. 1655 1656 So instead what we do is construct the number in hex (because 1657 it's easy to get the exact correct value), parse it as a real, 1658 then print it back out as decimal. */ 1659 1660 real_from_string (&real, hex_str); 1661 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0, 1662 TYPE_MODE (type)); 1663 1664 /* Assemble the macro in the following fashion 1665 macro = fp_cast [dec_str fp_suffix] */ 1666 sprintf (buf2, "%s%s", dec_str, fp_suffix); 1667 sprintf (buf1, fp_cast, buf2); 1668 sprintf (buf, "%s=%s", macro, buf1); 1669 1670 cpp_define (parse_in, buf); 1671 } 1672 1673 /* Return a string constant for the suffix for a value of type TYPE 1674 promoted according to the integer promotions. The type must be one 1675 of the standard integer type nodes. */ 1676 1677 static const char * 1678 type_suffix (tree type) 1679 { 1680 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; 1681 int unsigned_suffix; 1682 int is_long; 1683 int tp = TYPE_PRECISION (type); 1684 1685 if (type == long_long_integer_type_node 1686 || type == long_long_unsigned_type_node 1687 || tp > TYPE_PRECISION (long_integer_type_node)) 1688 is_long = 2; 1689 else if (type == long_integer_type_node 1690 || type == long_unsigned_type_node 1691 || tp > TYPE_PRECISION (integer_type_node)) 1692 is_long = 1; 1693 else if (type == integer_type_node 1694 || type == unsigned_type_node 1695 || type == short_integer_type_node 1696 || type == short_unsigned_type_node 1697 || type == signed_char_type_node 1698 || type == unsigned_char_type_node 1699 /* ??? "char" is not a signed or unsigned integer type and 1700 so is not permitted for the standard typedefs, but some 1701 systems use it anyway. */ 1702 || type == char_type_node) 1703 is_long = 0; 1704 else 1705 gcc_unreachable (); 1706 1707 unsigned_suffix = TYPE_UNSIGNED (type); 1708 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) 1709 unsigned_suffix = 0; 1710 return suffixes[is_long * 2 + unsigned_suffix]; 1711 } 1712 1713 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */ 1714 static void 1715 builtin_define_constants (const char *macro, tree type) 1716 { 1717 const char *suffix; 1718 char *buf; 1719 1720 suffix = type_suffix (type); 1721 1722 if (suffix[0] == 0) 1723 { 1724 buf = (char *) alloca (strlen (macro) + 6); 1725 sprintf (buf, "%s(c)=c", macro); 1726 } 1727 else 1728 { 1729 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1); 1730 sprintf (buf, "%s(c)=c ## %s", macro, suffix); 1731 } 1732 1733 cpp_define (parse_in, buf); 1734 } 1735 1736 /* Define MAX for TYPE based on the precision of the type. */ 1737 1738 static void 1739 builtin_define_type_max (const char *macro, tree type) 1740 { 1741 builtin_define_type_minmax (NULL, macro, type); 1742 } 1743 1744 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal 1745 representation of that value. For example, a COUNT of 10 would 1746 return "0x3ff". */ 1747 1748 static void 1749 print_bits_of_hex (char *buf, int bufsz, int count) 1750 { 1751 gcc_assert (bufsz > 3); 1752 *buf++ = '0'; 1753 *buf++ = 'x'; 1754 bufsz -= 2; 1755 1756 gcc_assert (count > 0); 1757 1758 switch (count % 4) { 1759 case 0: 1760 break; 1761 case 1: 1762 *buf++ = '1'; 1763 bufsz --; 1764 count -= 1; 1765 break; 1766 case 2: 1767 *buf++ = '3'; 1768 bufsz --; 1769 count -= 2; 1770 break; 1771 case 3: 1772 *buf++ = '7'; 1773 bufsz --; 1774 count -= 3; 1775 break; 1776 } 1777 while (count >= 4) 1778 { 1779 gcc_assert (bufsz > 1); 1780 *buf++ = 'f'; 1781 bufsz --; 1782 count -= 4; 1783 } 1784 gcc_assert (bufsz > 0); 1785 *buf++ = 0; 1786 } 1787 1788 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the 1789 precision of the type. */ 1790 1791 static void 1792 builtin_define_type_minmax (const char *min_macro, const char *max_macro, 1793 tree type) 1794 { 1795 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4) 1796 char value[PBOH_SZ]; 1797 1798 const char *suffix; 1799 char *buf; 1800 int bits; 1801 1802 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1); 1803 1804 print_bits_of_hex (value, PBOH_SZ, bits); 1805 1806 suffix = type_suffix (type); 1807 1808 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value) 1809 + strlen (suffix) + 1); 1810 sprintf (buf, "%s=%s%s", max_macro, value, suffix); 1811 1812 cpp_define (parse_in, buf); 1813 1814 if (min_macro) 1815 { 1816 if (TYPE_UNSIGNED (type)) 1817 { 1818 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1); 1819 sprintf (buf, "%s=0%s", min_macro, suffix); 1820 } 1821 else 1822 { 1823 buf = (char *) alloca (strlen (min_macro) + 3 1824 + strlen (max_macro) + 6); 1825 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro); 1826 } 1827 cpp_define (parse_in, buf); 1828 } 1829 } 1830 1831 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL, 1832 both types must have the same width. */ 1833 1834 static void 1835 builtin_define_type_width (const char *width_macro, tree type, tree type2) 1836 { 1837 if (type2 != NULL_TREE) 1838 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2)); 1839 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type)); 1840 } 1841 1842 #include "gt-c-family-c-cppbuiltin.h" 1843