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