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