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