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