1 /* Define builtin-in macros for the C family front ends. 2 Copyright (C) 2002-2013 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 "tm.h" 24 #include "tree.h" 25 #include "version.h" 26 #include "flags.h" 27 #include "c-common.h" 28 #include "c-pragma.h" 29 #include "output.h" /* For user_label_prefix. */ 30 #include "debug.h" /* For dwarf2out_do_cfi_asm. */ 31 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */ 32 #include "target.h" 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 void builtin_define_std (const char *) ATTRIBUTE_UNUSED; 51 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT); 52 static void builtin_define_with_hex_fp_value (const char *, tree, 53 int, const char *, 54 const char *, 55 const char *); 56 static void builtin_define_stdint_macros (void); 57 static void builtin_define_constants (const char *, tree); 58 static void builtin_define_type_max (const char *, tree); 59 static void builtin_define_type_minmax (const char *, const char *, tree); 60 static void builtin_define_type_sizeof (const char *, tree); 61 static void builtin_define_float_constants (const char *, 62 const char *, 63 const char *, 64 const char *, 65 tree); 66 67 /* Return true if MODE provides a fast multiply/add (FMA) builtin function. 68 Originally this function used the fma optab, but that doesn't work with 69 -save-temps, so just rely on the HAVE_fma macros for the standard floating 70 point types. */ 71 72 static bool 73 mode_has_fma (enum machine_mode mode) 74 { 75 switch (mode) 76 { 77 #ifdef HAVE_fmasf4 78 case SFmode: 79 return !!HAVE_fmasf4; 80 #endif 81 82 #ifdef HAVE_fmadf4 83 case DFmode: 84 return !!HAVE_fmadf4; 85 #endif 86 87 #ifdef HAVE_fmaxf4 88 case XFmode: 89 return !!HAVE_fmaxf4; 90 #endif 91 92 #ifdef HAVE_fmatf4 93 case TFmode: 94 return !!HAVE_fmatf4; 95 #endif 96 97 default: 98 break; 99 } 100 101 return false; 102 } 103 104 /* Define NAME with value TYPE size_unit. */ 105 static void 106 builtin_define_type_sizeof (const char *name, tree type) 107 { 108 builtin_define_with_int_value (name, 109 tree_low_cst (TYPE_SIZE_UNIT (type), 1)); 110 } 111 112 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX, 113 and FP_CAST. */ 114 static void 115 builtin_define_float_constants (const char *name_prefix, 116 const char *fp_suffix, 117 const char *fp_cast, 118 const char *fma_suffix, 119 tree type) 120 { 121 /* Used to convert radix-based values to base 10 values in several cases. 122 123 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at 124 least 6 significant digits for correct results. Using the fraction 125 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an 126 intermediate; perhaps someone can find a better approximation, in the 127 mean time, I suspect using doubles won't harm the bootstrap here. */ 128 129 const double log10_2 = .30102999566398119521; 130 double log10_b; 131 const struct real_format *fmt; 132 const struct real_format *ldfmt; 133 134 char name[64], buf[128]; 135 int dig, min_10_exp, max_10_exp; 136 int decimal_dig; 137 int type_decimal_dig; 138 139 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 140 gcc_assert (fmt->b != 10); 141 ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node)); 142 gcc_assert (ldfmt->b != 10); 143 144 /* The radix of the exponent representation. */ 145 if (type == float_type_node) 146 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b); 147 log10_b = log10_2; 148 149 /* The number of radix digits, p, in the floating-point significand. */ 150 sprintf (name, "__%s_MANT_DIG__", name_prefix); 151 builtin_define_with_int_value (name, fmt->p); 152 153 /* The number of decimal digits, q, such that any floating-point number 154 with q decimal digits can be rounded into a floating-point number with 155 p radix b digits and back again without change to the q decimal digits, 156 157 p log10 b if b is a power of 10 158 floor((p - 1) log10 b) otherwise 159 */ 160 dig = (fmt->p - 1) * log10_b; 161 sprintf (name, "__%s_DIG__", name_prefix); 162 builtin_define_with_int_value (name, dig); 163 164 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 165 sprintf (name, "__%s_MIN_EXP__", name_prefix); 166 sprintf (buf, "(%d)", fmt->emin); 167 builtin_define_with_value (name, buf, 0); 168 169 /* The minimum negative int x such that 10**x is a normalized float, 170 171 ceil (log10 (b ** (emin - 1))) 172 = ceil (log10 (b) * (emin - 1)) 173 174 Recall that emin is negative, so the integer truncation calculates 175 the ceiling, not the floor, in this case. */ 176 min_10_exp = (fmt->emin - 1) * log10_b; 177 sprintf (name, "__%s_MIN_10_EXP__", name_prefix); 178 sprintf (buf, "(%d)", min_10_exp); 179 builtin_define_with_value (name, buf, 0); 180 181 /* The maximum int x such that b**(x-1) is a representable float. */ 182 sprintf (name, "__%s_MAX_EXP__", name_prefix); 183 builtin_define_with_int_value (name, fmt->emax); 184 185 /* The maximum int x such that 10**x is in the range of representable 186 finite floating-point numbers, 187 188 floor (log10((1 - b**-p) * b**emax)) 189 = floor (log10(1 - b**-p) + log10(b**emax)) 190 = floor (log10(1 - b**-p) + log10(b)*emax) 191 192 The safest thing to do here is to just compute this number. But since 193 we don't link cc1 with libm, we cannot. We could implement log10 here 194 a series expansion, but that seems too much effort because: 195 196 Note that the first term, for all extant p, is a number exceedingly close 197 to zero, but slightly negative. Note that the second term is an integer 198 scaling an irrational number, and that because of the floor we are only 199 interested in its integral portion. 200 201 In order for the first term to have any effect on the integral portion 202 of the second term, the second term has to be exceedingly close to an 203 integer itself (e.g. 123.000000000001 or something). Getting a result 204 that close to an integer requires that the irrational multiplicand have 205 a long series of zeros in its expansion, which doesn't occur in the 206 first 20 digits or so of log10(b). 207 208 Hand-waving aside, crunching all of the sets of constants above by hand 209 does not yield a case for which the first term is significant, which 210 in the end is all that matters. */ 211 max_10_exp = fmt->emax * log10_b; 212 sprintf (name, "__%s_MAX_10_EXP__", name_prefix); 213 builtin_define_with_int_value (name, max_10_exp); 214 215 /* The number of decimal digits, n, such that any floating-point number 216 can be rounded to n decimal digits and back again without change to 217 the value. 218 219 p * log10(b) if b is a power of 10 220 ceil(1 + p * log10(b)) otherwise 221 222 The only macro we care about is this number for the widest supported 223 floating type, but we want this value for rendering constants below. */ 224 { 225 double d_decimal_dig 226 = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b; 227 decimal_dig = d_decimal_dig; 228 if (decimal_dig < d_decimal_dig) 229 decimal_dig++; 230 } 231 /* Similar, for this type rather than long double. */ 232 { 233 double type_d_decimal_dig = 1 + fmt->p * log10_b; 234 type_decimal_dig = type_d_decimal_dig; 235 if (type_decimal_dig < type_d_decimal_dig) 236 type_decimal_dig++; 237 } 238 if (type == long_double_type_node) 239 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig); 240 else 241 { 242 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix); 243 builtin_define_with_int_value (name, type_decimal_dig); 244 } 245 246 /* Since, for the supported formats, B is always a power of 2, we 247 construct the following numbers directly as a hexadecimal 248 constants. */ 249 get_max_float (fmt, buf, sizeof (buf)); 250 251 sprintf (name, "__%s_MAX__", name_prefix); 252 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 253 254 /* The minimum normalized positive floating-point number, 255 b**(emin-1). */ 256 sprintf (name, "__%s_MIN__", name_prefix); 257 sprintf (buf, "0x1p%d", fmt->emin - 1); 258 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 259 260 /* The difference between 1 and the least value greater than 1 that is 261 representable in the given floating point type, b**(1-p). */ 262 sprintf (name, "__%s_EPSILON__", name_prefix); 263 if (fmt->pnan < fmt->p) 264 /* This is an IBM extended double format, so 1.0 + any double is 265 representable precisely. */ 266 sprintf (buf, "0x1p%d", fmt->emin - fmt->p); 267 else 268 sprintf (buf, "0x1p%d", 1 - fmt->p); 269 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 270 271 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized 272 positive floating-point number, b**(emin-p). Zero for formats that 273 don't support denormals. */ 274 sprintf (name, "__%s_DENORM_MIN__", name_prefix); 275 if (fmt->has_denorm) 276 { 277 sprintf (buf, "0x1p%d", fmt->emin - fmt->p); 278 builtin_define_with_hex_fp_value (name, type, decimal_dig, 279 buf, fp_suffix, fp_cast); 280 } 281 else 282 { 283 sprintf (buf, "0.0%s", fp_suffix); 284 builtin_define_with_value (name, buf, 0); 285 } 286 287 sprintf (name, "__%s_HAS_DENORM__", name_prefix); 288 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0); 289 290 /* For C++ std::numeric_limits<T>::has_infinity. */ 291 sprintf (name, "__%s_HAS_INFINITY__", name_prefix); 292 builtin_define_with_int_value (name, 293 MODE_HAS_INFINITIES (TYPE_MODE (type))); 294 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a 295 predicate to distinguish a target that has both quiet and 296 signalling NaNs from a target that has only quiet NaNs or only 297 signalling NaNs, so we assume that a target that has any kind of 298 NaN has quiet NaNs. */ 299 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix); 300 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type))); 301 302 /* Note whether we have fast FMA. */ 303 if (mode_has_fma (TYPE_MODE (type))) 304 { 305 sprintf (name, "__FP_FAST_FMA%s", fma_suffix); 306 builtin_define_with_int_value (name, 1); 307 } 308 } 309 310 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */ 311 static void 312 builtin_define_decimal_float_constants (const char *name_prefix, 313 const char *suffix, 314 tree type) 315 { 316 const struct real_format *fmt; 317 char name[64], buf[128], *p; 318 int digits; 319 320 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 321 322 /* The number of radix digits, p, in the significand. */ 323 sprintf (name, "__%s_MANT_DIG__", name_prefix); 324 builtin_define_with_int_value (name, fmt->p); 325 326 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 327 sprintf (name, "__%s_MIN_EXP__", name_prefix); 328 sprintf (buf, "(%d)", fmt->emin); 329 builtin_define_with_value (name, buf, 0); 330 331 /* The maximum int x such that b**(x-1) is a representable float. */ 332 sprintf (name, "__%s_MAX_EXP__", name_prefix); 333 builtin_define_with_int_value (name, fmt->emax); 334 335 /* Compute the minimum representable value. */ 336 sprintf (name, "__%s_MIN__", name_prefix); 337 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix); 338 builtin_define_with_value (name, buf, 0); 339 340 /* Compute the maximum representable value. */ 341 sprintf (name, "__%s_MAX__", name_prefix); 342 p = buf; 343 for (digits = fmt->p; digits; digits--) 344 { 345 *p++ = '9'; 346 if (digits == fmt->p) 347 *p++ = '.'; 348 } 349 *p = 0; 350 /* fmt->p plus 1, to account for the decimal point and fmt->emax 351 minus 1 because the digits are nines, not 1.0. */ 352 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix); 353 builtin_define_with_value (name, buf, 0); 354 355 /* Compute epsilon (the difference between 1 and least value greater 356 than 1 representable). */ 357 sprintf (name, "__%s_EPSILON__", name_prefix); 358 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix); 359 builtin_define_with_value (name, buf, 0); 360 361 /* Minimum subnormal positive decimal value. */ 362 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix); 363 p = buf; 364 for (digits = fmt->p; digits > 1; digits--) 365 { 366 *p++ = '0'; 367 if (digits == fmt->p) 368 *p++ = '.'; 369 } 370 *p = 0; 371 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix); 372 builtin_define_with_value (name, buf, 0); 373 } 374 375 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */ 376 377 static void 378 builtin_define_fixed_point_constants (const char *name_prefix, 379 const char *suffix, 380 tree type) 381 { 382 char name[64], buf[256], *new_buf; 383 int i, mod; 384 385 sprintf (name, "__%s_FBIT__", name_prefix); 386 builtin_define_with_int_value (name, TYPE_FBIT (type)); 387 388 sprintf (name, "__%s_IBIT__", name_prefix); 389 builtin_define_with_int_value (name, TYPE_IBIT (type)); 390 391 /* If there is no suffix, defines are for fixed-point modes. 392 We just return. */ 393 if (strcmp (suffix, "") == 0) 394 return; 395 396 if (TYPE_UNSIGNED (type)) 397 { 398 sprintf (name, "__%s_MIN__", name_prefix); 399 sprintf (buf, "0.0%s", suffix); 400 builtin_define_with_value (name, buf, 0); 401 } 402 else 403 { 404 sprintf (name, "__%s_MIN__", name_prefix); 405 if (ALL_ACCUM_MODE_P (TYPE_MODE (type))) 406 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix, 407 TYPE_IBIT (type) - 1, suffix); 408 else 409 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix); 410 builtin_define_with_value (name, buf, 0); 411 } 412 413 sprintf (name, "__%s_MAX__", name_prefix); 414 sprintf (buf, "0X"); 415 new_buf = buf + 2; 416 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4; 417 if (mod) 418 sprintf (new_buf++, "%x", (1 << mod) - 1); 419 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++) 420 sprintf (new_buf++, "F"); 421 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix); 422 builtin_define_with_value (name, buf, 0); 423 424 sprintf (name, "__%s_EPSILON__", name_prefix); 425 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix); 426 builtin_define_with_value (name, buf, 0); 427 } 428 429 /* Define macros used by <stdint.h>. */ 430 static void 431 builtin_define_stdint_macros (void) 432 { 433 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node); 434 builtin_define_constants ("__INTMAX_C", intmax_type_node); 435 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node); 436 builtin_define_constants ("__UINTMAX_C", uintmax_type_node); 437 if (sig_atomic_type_node) 438 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__", 439 sig_atomic_type_node); 440 if (int8_type_node) 441 builtin_define_type_max ("__INT8_MAX__", int8_type_node); 442 if (int16_type_node) 443 builtin_define_type_max ("__INT16_MAX__", int16_type_node); 444 if (int32_type_node) 445 builtin_define_type_max ("__INT32_MAX__", int32_type_node); 446 if (int64_type_node) 447 builtin_define_type_max ("__INT64_MAX__", int64_type_node); 448 if (uint8_type_node) 449 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node); 450 if (c_uint16_type_node) 451 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node); 452 if (c_uint32_type_node) 453 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node); 454 if (c_uint64_type_node) 455 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node); 456 if (int_least8_type_node) 457 { 458 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node); 459 builtin_define_constants ("__INT8_C", int_least8_type_node); 460 } 461 if (int_least16_type_node) 462 { 463 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node); 464 builtin_define_constants ("__INT16_C", int_least16_type_node); 465 } 466 if (int_least32_type_node) 467 { 468 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node); 469 builtin_define_constants ("__INT32_C", int_least32_type_node); 470 } 471 if (int_least64_type_node) 472 { 473 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node); 474 builtin_define_constants ("__INT64_C", int_least64_type_node); 475 } 476 if (uint_least8_type_node) 477 { 478 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node); 479 builtin_define_constants ("__UINT8_C", uint_least8_type_node); 480 } 481 if (uint_least16_type_node) 482 { 483 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node); 484 builtin_define_constants ("__UINT16_C", uint_least16_type_node); 485 } 486 if (uint_least32_type_node) 487 { 488 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node); 489 builtin_define_constants ("__UINT32_C", uint_least32_type_node); 490 } 491 if (uint_least64_type_node) 492 { 493 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node); 494 builtin_define_constants ("__UINT64_C", uint_least64_type_node); 495 } 496 if (int_fast8_type_node) 497 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node); 498 if (int_fast16_type_node) 499 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node); 500 if (int_fast32_type_node) 501 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node); 502 if (int_fast64_type_node) 503 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node); 504 if (uint_fast8_type_node) 505 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node); 506 if (uint_fast16_type_node) 507 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node); 508 if (uint_fast32_type_node) 509 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node); 510 if (uint_fast64_type_node) 511 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node); 512 if (intptr_type_node) 513 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node); 514 if (uintptr_type_node) 515 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node); 516 } 517 518 /* Adjust the optimization macros when a #pragma GCC optimization is done to 519 reflect the current level. */ 520 void 521 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree, 522 tree cur_tree) 523 { 524 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree); 525 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree); 526 bool prev_fast_math; 527 bool cur_fast_math; 528 529 /* -undef turns off target-specific built-ins. */ 530 if (flag_undef) 531 return; 532 533 /* Other target-independent built-ins determined by command-line 534 options. */ 535 if (!prev->x_optimize_size && cur->x_optimize_size) 536 cpp_define (pfile, "__OPTIMIZE_SIZE__"); 537 else if (prev->x_optimize_size && !cur->x_optimize_size) 538 cpp_undef (pfile, "__OPTIMIZE_SIZE__"); 539 540 if (!prev->x_optimize && cur->x_optimize) 541 cpp_define (pfile, "__OPTIMIZE__"); 542 else if (prev->x_optimize && !cur->x_optimize) 543 cpp_undef (pfile, "__OPTIMIZE__"); 544 545 prev_fast_math = fast_math_flags_struct_set_p (prev); 546 cur_fast_math = fast_math_flags_struct_set_p (cur); 547 if (!prev_fast_math && cur_fast_math) 548 cpp_define (pfile, "__FAST_MATH__"); 549 else if (prev_fast_math && !cur_fast_math) 550 cpp_undef (pfile, "__FAST_MATH__"); 551 552 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans) 553 cpp_define (pfile, "__SUPPORT_SNAN__"); 554 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans) 555 cpp_undef (pfile, "__SUPPORT_SNAN__"); 556 557 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only) 558 { 559 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); 560 cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); 561 } 562 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only) 563 { 564 cpp_undef (pfile, "__FINITE_MATH_ONLY__"); 565 cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); 566 } 567 } 568 569 570 /* This function will emit cpp macros to indicate the presence of various lock 571 free atomic operations. */ 572 573 static void 574 cpp_atomic_builtins (cpp_reader *pfile) 575 { 576 /* Set a flag for each size of object that compare and swap exists for up to 577 a 16 byte object. */ 578 #define SWAP_LIMIT 17 579 bool have_swap[SWAP_LIMIT]; 580 unsigned int psize; 581 582 /* Clear the map of sizes compare_and swap exists for. */ 583 memset (have_swap, 0, sizeof (have_swap)); 584 585 /* Tell source code if the compiler makes sync_compare_and_swap 586 builtins available. */ 587 #ifndef HAVE_sync_compare_and_swapqi 588 #define HAVE_sync_compare_and_swapqi 0 589 #endif 590 #ifndef HAVE_atomic_compare_and_swapqi 591 #define HAVE_atomic_compare_and_swapqi 0 592 #endif 593 594 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi) 595 { 596 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1"); 597 have_swap[1] = true; 598 } 599 600 #ifndef HAVE_sync_compare_and_swaphi 601 #define HAVE_sync_compare_and_swaphi 0 602 #endif 603 #ifndef HAVE_atomic_compare_and_swaphi 604 #define HAVE_atomic_compare_and_swaphi 0 605 #endif 606 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi) 607 { 608 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2"); 609 have_swap[2] = true; 610 } 611 612 #ifndef HAVE_sync_compare_and_swapsi 613 #define HAVE_sync_compare_and_swapsi 0 614 #endif 615 #ifndef HAVE_atomic_compare_and_swapsi 616 #define HAVE_atomic_compare_and_swapsi 0 617 #endif 618 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi) 619 { 620 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4"); 621 have_swap[4] = true; 622 } 623 624 #ifndef HAVE_sync_compare_and_swapdi 625 #define HAVE_sync_compare_and_swapdi 0 626 #endif 627 #ifndef HAVE_atomic_compare_and_swapdi 628 #define HAVE_atomic_compare_and_swapdi 0 629 #endif 630 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi) 631 { 632 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8"); 633 have_swap[8] = true; 634 } 635 636 #ifndef HAVE_sync_compare_and_swapti 637 #define HAVE_sync_compare_and_swapti 0 638 #endif 639 #ifndef HAVE_atomic_compare_and_swapti 640 #define HAVE_atomic_compare_and_swapti 0 641 #endif 642 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti) 643 { 644 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16"); 645 have_swap[16] = true; 646 } 647 648 /* Tell the source code about various types. These map to the C++11 and C11 649 macros where 2 indicates lock-free always, and 1 indicates sometimes 650 lock free. */ 651 #define SIZEOF_NODE(T) (tree_low_cst (TYPE_SIZE_UNIT (T), 1)) 652 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0) 653 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE", 654 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1)); 655 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE", 656 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1)); 657 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE", 658 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1)); 659 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE", 660 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1)); 661 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE", 662 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1)); 663 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE", 664 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1)); 665 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE", 666 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1)); 667 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE", 668 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1)); 669 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE", 670 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1)); 671 672 /* If we're dealing with a "set" value that doesn't exactly correspond 673 to a boolean truth value, let the library work around that. */ 674 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL", 675 targetm.atomic_test_and_set_trueval); 676 677 /* ptr_type_node can't be used here since ptr_mode is only set when 678 toplev calls backend_init which is not done with -E or pch. */ 679 psize = POINTER_SIZE / BITS_PER_UNIT; 680 if (psize >= SWAP_LIMIT) 681 psize = 0; 682 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE", 683 (have_swap[psize]? 2 : 1)); 684 } 685 686 /* Hook that registers front end and target-specific built-ins. */ 687 void 688 c_cpp_builtins (cpp_reader *pfile) 689 { 690 /* -undef turns off target-specific built-ins. */ 691 if (flag_undef) 692 return; 693 694 define_language_independent_builtin_macros (pfile); 695 696 if (c_dialect_cxx ()) 697 { 698 int major; 699 parse_basever (&major, NULL, NULL); 700 cpp_define_formatted (pfile, "__GNUG__=%d", major); 701 } 702 703 /* For stddef.h. They require macros defined in c-common.c. */ 704 c_stddef_cpp_builtins (); 705 706 if (c_dialect_cxx ()) 707 { 708 if (flag_weak && SUPPORTS_ONE_ONLY) 709 cpp_define (pfile, "__GXX_WEAK__=1"); 710 else 711 cpp_define (pfile, "__GXX_WEAK__=0"); 712 if (warn_deprecated) 713 cpp_define (pfile, "__DEPRECATED"); 714 if (flag_rtti) 715 cpp_define (pfile, "__GXX_RTTI"); 716 if (cxx_dialect >= cxx0x) 717 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__"); 718 } 719 /* Note that we define this for C as well, so that we know if 720 __attribute__((cleanup)) will interface with EH. */ 721 if (flag_exceptions) 722 cpp_define (pfile, "__EXCEPTIONS"); 723 724 /* Represents the C++ ABI version, always defined so it can be used while 725 preprocessing C and assembler. */ 726 if (flag_abi_version == 0) 727 /* Use a very large value so that: 728 729 #if __GXX_ABI_VERSION >= <value for version X> 730 731 will work whether the user explicitly says "-fabi-version=x" or 732 "-fabi-version=0". Do not use INT_MAX because that will be 733 different from system to system. */ 734 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); 735 else if (flag_abi_version == 1) 736 /* Due to a historical accident, this version had the value 737 "102". */ 738 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); 739 else 740 /* Newer versions have values 1002, 1003, .... */ 741 builtin_define_with_int_value ("__GXX_ABI_VERSION", 742 1000 + flag_abi_version); 743 744 /* libgcc needs to know this. */ 745 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ) 746 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); 747 748 /* limits.h and stdint.h need to know these. */ 749 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node); 750 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node); 751 builtin_define_type_max ("__INT_MAX__", integer_type_node); 752 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node); 753 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node); 754 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__", 755 underlying_wchar_type_node); 756 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node); 757 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node); 758 builtin_define_type_max ("__SIZE_MAX__", size_type_node); 759 760 /* stdint.h and the testsuite need to know these. */ 761 builtin_define_stdint_macros (); 762 763 /* float.h needs to know this. */ 764 builtin_define_with_int_value ("__FLT_EVAL_METHOD__", 765 TARGET_FLT_EVAL_METHOD); 766 767 /* And decfloat.h needs this. */ 768 builtin_define_with_int_value ("__DEC_EVAL_METHOD__", 769 TARGET_DEC_EVAL_METHOD); 770 771 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node); 772 /* Cast the double precision constants. This is needed when single 773 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64 774 is used. The correct result is computed by the compiler when using 775 macros that include a cast. We use a different cast for C++ to avoid 776 problems with -Wold-style-cast. */ 777 builtin_define_float_constants ("DBL", "L", 778 (c_dialect_cxx () 779 ? "double(%s)" 780 : "((double)%s)"), 781 "", double_type_node); 782 builtin_define_float_constants ("LDBL", "L", "%s", "L", 783 long_double_type_node); 784 785 /* For decfloat.h. */ 786 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); 787 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); 788 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); 789 790 /* For fixed-point fibt, ibit, max, min, and epsilon. */ 791 if (targetm.fixed_point_supported_p ()) 792 { 793 builtin_define_fixed_point_constants ("SFRACT", "HR", 794 short_fract_type_node); 795 builtin_define_fixed_point_constants ("USFRACT", "UHR", 796 unsigned_short_fract_type_node); 797 builtin_define_fixed_point_constants ("FRACT", "R", 798 fract_type_node); 799 builtin_define_fixed_point_constants ("UFRACT", "UR", 800 unsigned_fract_type_node); 801 builtin_define_fixed_point_constants ("LFRACT", "LR", 802 long_fract_type_node); 803 builtin_define_fixed_point_constants ("ULFRACT", "ULR", 804 unsigned_long_fract_type_node); 805 builtin_define_fixed_point_constants ("LLFRACT", "LLR", 806 long_long_fract_type_node); 807 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR", 808 unsigned_long_long_fract_type_node); 809 builtin_define_fixed_point_constants ("SACCUM", "HK", 810 short_accum_type_node); 811 builtin_define_fixed_point_constants ("USACCUM", "UHK", 812 unsigned_short_accum_type_node); 813 builtin_define_fixed_point_constants ("ACCUM", "K", 814 accum_type_node); 815 builtin_define_fixed_point_constants ("UACCUM", "UK", 816 unsigned_accum_type_node); 817 builtin_define_fixed_point_constants ("LACCUM", "LK", 818 long_accum_type_node); 819 builtin_define_fixed_point_constants ("ULACCUM", "ULK", 820 unsigned_long_accum_type_node); 821 builtin_define_fixed_point_constants ("LLACCUM", "LLK", 822 long_long_accum_type_node); 823 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK", 824 unsigned_long_long_accum_type_node); 825 826 builtin_define_fixed_point_constants ("QQ", "", qq_type_node); 827 builtin_define_fixed_point_constants ("HQ", "", hq_type_node); 828 builtin_define_fixed_point_constants ("SQ", "", sq_type_node); 829 builtin_define_fixed_point_constants ("DQ", "", dq_type_node); 830 builtin_define_fixed_point_constants ("TQ", "", tq_type_node); 831 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node); 832 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node); 833 builtin_define_fixed_point_constants ("USQ", "", usq_type_node); 834 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node); 835 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node); 836 builtin_define_fixed_point_constants ("HA", "", ha_type_node); 837 builtin_define_fixed_point_constants ("SA", "", sa_type_node); 838 builtin_define_fixed_point_constants ("DA", "", da_type_node); 839 builtin_define_fixed_point_constants ("TA", "", ta_type_node); 840 builtin_define_fixed_point_constants ("UHA", "", uha_type_node); 841 builtin_define_fixed_point_constants ("USA", "", usa_type_node); 842 builtin_define_fixed_point_constants ("UDA", "", uda_type_node); 843 builtin_define_fixed_point_constants ("UTA", "", uta_type_node); 844 } 845 846 /* For libgcc-internal use only. */ 847 if (flag_building_libgcc) 848 /* For libgcc enable-execute-stack.c. */ 849 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__", 850 TRAMPOLINE_SIZE); 851 852 /* For use in assembly language. */ 853 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); 854 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); 855 856 /* Misc. */ 857 if (flag_gnu89_inline) 858 cpp_define (pfile, "__GNUC_GNU_INLINE__"); 859 else 860 cpp_define (pfile, "__GNUC_STDC_INLINE__"); 861 862 if (flag_no_inline) 863 cpp_define (pfile, "__NO_INLINE__"); 864 865 if (flag_iso) 866 cpp_define (pfile, "__STRICT_ANSI__"); 867 868 if (!flag_signed_char) 869 cpp_define (pfile, "__CHAR_UNSIGNED__"); 870 871 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) 872 cpp_define (pfile, "__WCHAR_UNSIGNED__"); 873 874 cpp_atomic_builtins (pfile); 875 876 #ifdef DWARF2_UNWIND_INFO 877 if (dwarf2out_do_cfi_asm ()) 878 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM"); 879 #endif 880 881 /* Make the choice of ObjC runtime visible to source code. */ 882 if (c_dialect_objc () && flag_next_runtime) 883 cpp_define (pfile, "__NEXT_RUNTIME__"); 884 885 /* Show the availability of some target pragmas. */ 886 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); 887 888 /* Make the choice of the stack protector runtime visible to source code. 889 The macro names and values here were chosen for compatibility with an 890 earlier implementation, i.e. ProPolice. */ 891 if (flag_stack_protect == 2) 892 cpp_define (pfile, "__SSP_ALL__=2"); 893 else if (flag_stack_protect == 1) 894 cpp_define (pfile, "__SSP__=1"); 895 896 if (flag_openmp) 897 cpp_define (pfile, "_OPENMP=201107"); 898 899 if (int128_integer_type_node != NULL_TREE) 900 builtin_define_type_sizeof ("__SIZEOF_INT128__", 901 int128_integer_type_node); 902 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node); 903 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node); 904 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__", 905 unsigned_ptrdiff_type_node); 906 907 /* A straightforward target hook doesn't work, because of problems 908 linking that hook's body when part of non-C front ends. */ 909 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) 910 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) 911 # define builtin_define(TXT) cpp_define (pfile, TXT) 912 # define builtin_assert(TXT) cpp_assert (pfile, TXT) 913 TARGET_CPU_CPP_BUILTINS (); 914 TARGET_OS_CPP_BUILTINS (); 915 TARGET_OBJFMT_CPP_BUILTINS (); 916 917 /* Support the __declspec keyword by turning them into attributes. 918 Note that the current way we do this may result in a collision 919 with predefined attributes later on. This can be solved by using 920 one attribute, say __declspec__, and passing args to it. The 921 problem with that approach is that args are not accumulated: each 922 new appearance would clobber any existing args. */ 923 if (TARGET_DECLSPEC) 924 builtin_define ("__declspec(x)=__attribute__((x))"); 925 926 /* If decimal floating point is supported, tell the user if the 927 alternate format (BID) is used instead of the standard (DPD) 928 format. */ 929 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT) 930 cpp_define (pfile, "__DECIMAL_BID_FORMAT__"); 931 } 932 933 /* Pass an object-like macro. If it doesn't lie in the user's 934 namespace, defines it unconditionally. Otherwise define a version 935 with two leading underscores, and another version with two leading 936 and trailing underscores, and define the original only if an ISO 937 standard was not nominated. 938 939 e.g. passing "unix" defines "__unix", "__unix__" and possibly 940 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly 941 "_mips". */ 942 void 943 builtin_define_std (const char *macro) 944 { 945 size_t len = strlen (macro); 946 char *buff = (char *) alloca (len + 5); 947 char *p = buff + 2; 948 char *q = p + len; 949 950 /* prepend __ (or maybe just _) if in user's namespace. */ 951 memcpy (p, macro, len + 1); 952 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) 953 { 954 if (*p != '_') 955 *--p = '_'; 956 if (p[1] != '_') 957 *--p = '_'; 958 } 959 cpp_define (parse_in, p); 960 961 /* If it was in user's namespace... */ 962 if (p != buff + 2) 963 { 964 /* Define the macro with leading and following __. */ 965 if (q[-1] != '_') 966 *q++ = '_'; 967 if (q[-2] != '_') 968 *q++ = '_'; 969 *q = '\0'; 970 cpp_define (parse_in, p); 971 972 /* Finally, define the original macro if permitted. */ 973 if (!flag_iso) 974 cpp_define (parse_in, macro); 975 } 976 } 977 978 /* Pass an object-like macro and a value to define it to. The third 979 parameter says whether or not to turn the value into a string 980 constant. */ 981 void 982 builtin_define_with_value (const char *macro, const char *expansion, int is_str) 983 { 984 char *buf; 985 size_t mlen = strlen (macro); 986 size_t elen = strlen (expansion); 987 size_t extra = 2; /* space for an = and a NUL */ 988 989 if (is_str) 990 extra += 2; /* space for two quote marks */ 991 992 buf = (char *) alloca (mlen + elen + extra); 993 if (is_str) 994 sprintf (buf, "%s=\"%s\"", macro, expansion); 995 else 996 sprintf (buf, "%s=%s", macro, expansion); 997 998 cpp_define (parse_in, buf); 999 } 1000 1001 1002 /* Pass an object-like macro and an integer value to define it to. */ 1003 static void 1004 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 1005 { 1006 char *buf; 1007 size_t mlen = strlen (macro); 1008 size_t vlen = 18; 1009 size_t extra = 2; /* space for = and NUL. */ 1010 1011 buf = (char *) alloca (mlen + vlen + extra); 1012 memcpy (buf, macro, mlen); 1013 buf[mlen] = '='; 1014 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); 1015 1016 cpp_define (parse_in, buf); 1017 } 1018 1019 /* builtin_define_with_hex_fp_value is very expensive, so the following 1020 array and function allows it to be done lazily when __DBL_MAX__ 1021 etc. is first used. */ 1022 1023 struct GTY(()) lazy_hex_fp_value_struct 1024 { 1025 const char *hex_str; 1026 cpp_macro *macro; 1027 enum machine_mode mode; 1028 int digits; 1029 const char *fp_suffix; 1030 }; 1031 static GTY(()) struct lazy_hex_fp_value_struct lazy_hex_fp_values[12]; 1032 static GTY(()) int lazy_hex_fp_value_count; 1033 1034 static bool 1035 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED, 1036 cpp_hashnode *node) 1037 { 1038 REAL_VALUE_TYPE real; 1039 char dec_str[64], buf1[256]; 1040 unsigned int idx; 1041 if (node->value.builtin < BT_FIRST_USER 1042 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count) 1043 return false; 1044 1045 idx = node->value.builtin - BT_FIRST_USER; 1046 real_from_string (&real, lazy_hex_fp_values[idx].hex_str); 1047 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), 1048 lazy_hex_fp_values[idx].digits, 0, 1049 lazy_hex_fp_values[idx].mode); 1050 1051 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix); 1052 node->flags &= ~(NODE_BUILTIN | NODE_USED); 1053 node->value.macro = lazy_hex_fp_values[idx].macro; 1054 for (idx = 0; idx < node->value.macro->count; idx++) 1055 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER) 1056 break; 1057 gcc_assert (idx < node->value.macro->count); 1058 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1); 1059 node->value.macro->exp.tokens[idx].val.str.text 1060 = (const unsigned char *) ggc_strdup (buf1); 1061 return true; 1062 } 1063 1064 /* Pass an object-like macro a hexadecimal floating-point value. */ 1065 static void 1066 builtin_define_with_hex_fp_value (const char *macro, 1067 tree type, int digits, 1068 const char *hex_str, 1069 const char *fp_suffix, 1070 const char *fp_cast) 1071 { 1072 REAL_VALUE_TYPE real; 1073 char dec_str[64], buf1[256], buf2[256]; 1074 1075 /* This is very expensive, so if possible expand them lazily. */ 1076 if (lazy_hex_fp_value_count < 12 1077 && flag_dump_macros == 0 1078 && !cpp_get_options (parse_in)->traditional) 1079 { 1080 struct cpp_hashnode *node; 1081 if (lazy_hex_fp_value_count == 0) 1082 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value; 1083 sprintf (buf2, fp_cast, "1.1"); 1084 sprintf (buf1, "%s=%s", macro, buf2); 1085 cpp_define (parse_in, buf1); 1086 node = C_CPP_HASHNODE (get_identifier (macro)); 1087 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str 1088 = ggc_strdup (hex_str); 1089 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type); 1090 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits; 1091 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix; 1092 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro; 1093 node->flags |= NODE_BUILTIN; 1094 node->value.builtin 1095 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count); 1096 lazy_hex_fp_value_count++; 1097 return; 1098 } 1099 1100 /* Hex values are really cool and convenient, except that they're 1101 not supported in strict ISO C90 mode. First, the "p-" sequence 1102 is not valid as part of a preprocessor number. Second, we get a 1103 pedwarn from the preprocessor, which has no context, so we can't 1104 suppress the warning with __extension__. 1105 1106 So instead what we do is construct the number in hex (because 1107 it's easy to get the exact correct value), parse it as a real, 1108 then print it back out as decimal. */ 1109 1110 real_from_string (&real, hex_str); 1111 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0, 1112 TYPE_MODE (type)); 1113 1114 /* Assemble the macro in the following fashion 1115 macro = fp_cast [dec_str fp_suffix] */ 1116 sprintf (buf1, "%s%s", dec_str, fp_suffix); 1117 sprintf (buf2, fp_cast, buf1); 1118 sprintf (buf1, "%s=%s", macro, buf2); 1119 1120 cpp_define (parse_in, buf1); 1121 } 1122 1123 /* Return a string constant for the suffix for a value of type TYPE 1124 promoted according to the integer promotions. The type must be one 1125 of the standard integer type nodes. */ 1126 1127 static const char * 1128 type_suffix (tree type) 1129 { 1130 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; 1131 int unsigned_suffix; 1132 int is_long; 1133 1134 if (type == long_long_integer_type_node 1135 || type == long_long_unsigned_type_node) 1136 is_long = 2; 1137 else if (type == long_integer_type_node 1138 || type == long_unsigned_type_node) 1139 is_long = 1; 1140 else if (type == integer_type_node 1141 || type == unsigned_type_node 1142 || type == short_integer_type_node 1143 || type == short_unsigned_type_node 1144 || type == signed_char_type_node 1145 || type == unsigned_char_type_node 1146 /* ??? "char" is not a signed or unsigned integer type and 1147 so is not permitted for the standard typedefs, but some 1148 systems use it anyway. */ 1149 || type == char_type_node) 1150 is_long = 0; 1151 else 1152 gcc_unreachable (); 1153 1154 unsigned_suffix = TYPE_UNSIGNED (type); 1155 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)) 1156 unsigned_suffix = 0; 1157 return suffixes[is_long * 2 + unsigned_suffix]; 1158 } 1159 1160 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */ 1161 static void 1162 builtin_define_constants (const char *macro, tree type) 1163 { 1164 const char *suffix; 1165 char *buf; 1166 1167 suffix = type_suffix (type); 1168 1169 if (suffix[0] == 0) 1170 { 1171 buf = (char *) alloca (strlen (macro) + 6); 1172 sprintf (buf, "%s(c)=c", macro); 1173 } 1174 else 1175 { 1176 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1); 1177 sprintf (buf, "%s(c)=c ## %s", macro, suffix); 1178 } 1179 1180 cpp_define (parse_in, buf); 1181 } 1182 1183 /* Define MAX for TYPE based on the precision of the type. */ 1184 1185 static void 1186 builtin_define_type_max (const char *macro, tree type) 1187 { 1188 builtin_define_type_minmax (NULL, macro, type); 1189 } 1190 1191 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the 1192 precision of the type. */ 1193 1194 static void 1195 builtin_define_type_minmax (const char *min_macro, const char *max_macro, 1196 tree type) 1197 { 1198 static const char *const values[] 1199 = { "127", "255", 1200 "32767", "65535", 1201 "2147483647", "4294967295", 1202 "9223372036854775807", "18446744073709551615", 1203 "170141183460469231731687303715884105727", 1204 "340282366920938463463374607431768211455" }; 1205 1206 const char *value, *suffix; 1207 char *buf; 1208 size_t idx; 1209 1210 /* Pre-rendering the values mean we don't have to futz with printing a 1211 multi-word decimal value. There are also a very limited number of 1212 precisions that we support, so it's really a waste of time. */ 1213 switch (TYPE_PRECISION (type)) 1214 { 1215 case 8: idx = 0; break; 1216 case 16: idx = 2; break; 1217 case 32: idx = 4; break; 1218 case 64: idx = 6; break; 1219 case 128: idx = 8; break; 1220 default: gcc_unreachable (); 1221 } 1222 1223 value = values[idx + TYPE_UNSIGNED (type)]; 1224 suffix = type_suffix (type); 1225 1226 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value) 1227 + strlen (suffix) + 1); 1228 sprintf (buf, "%s=%s%s", max_macro, value, suffix); 1229 1230 cpp_define (parse_in, buf); 1231 1232 if (min_macro) 1233 { 1234 if (TYPE_UNSIGNED (type)) 1235 { 1236 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1); 1237 sprintf (buf, "%s=0%s", min_macro, suffix); 1238 } 1239 else 1240 { 1241 buf = (char *) alloca (strlen (min_macro) + 3 1242 + strlen (max_macro) + 6); 1243 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro); 1244 } 1245 cpp_define (parse_in, buf); 1246 } 1247 } 1248 1249 #include "gt-c-family-c-cppbuiltin.h" 1250