c-cppbuiltin.c revision 264214
1/* Define builtin-in macros for the C family front ends. 2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007 3 Free Software Foundation, Inc. 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free 19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2002110-1301, USA. */ 21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26#include "tree.h" 27#include "version.h" 28#include "flags.h" 29#include "real.h" 30#include "c-common.h" 31#include "c-pragma.h" 32#include "output.h" 33#include "except.h" /* For USING_SJLJ_EXCEPTIONS. */ 34#include "toplev.h" 35#include "tm_p.h" /* Target prototypes. */ 36#include "target.h" 37 38#ifndef TARGET_OS_CPP_BUILTINS 39# define TARGET_OS_CPP_BUILTINS() 40#endif 41 42#ifndef TARGET_OBJFMT_CPP_BUILTINS 43# define TARGET_OBJFMT_CPP_BUILTINS() 44#endif 45 46#ifndef REGISTER_PREFIX 47#define REGISTER_PREFIX "" 48#endif 49 50/* Non-static as some targets don't use it. */ 51void builtin_define_std (const char *) ATTRIBUTE_UNUSED; 52static void builtin_define_with_value_n (const char *, const char *, 53 size_t); 54static void builtin_define_with_int_value (const char *, HOST_WIDE_INT); 55static void builtin_define_with_hex_fp_value (const char *, tree, 56 int, const char *, 57 const char *, 58 const char *); 59static void builtin_define_stdint_macros (void); 60static void builtin_define_type_max (const char *, tree, int); 61static void builtin_define_type_precision (const char *, tree); 62static void builtin_define_float_constants (const char *, 63 const char *, 64 const char *, 65 tree); 66static void define__GNUC__ (void); 67 68/* Define NAME with value TYPE precision. */ 69static void 70builtin_define_type_precision (const char *name, tree type) 71{ 72 builtin_define_with_int_value (name, TYPE_PRECISION (type)); 73} 74 75/* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX, 76 and FP_CAST. */ 77static void 78builtin_define_float_constants (const char *name_prefix, 79 const char *fp_suffix, 80 const char *fp_cast, 81 tree type) 82{ 83 /* Used to convert radix-based values to base 10 values in several cases. 84 85 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at 86 least 6 significant digits for correct results. Using the fraction 87 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an 88 intermediate; perhaps someone can find a better approximation, in the 89 mean time, I suspect using doubles won't harm the bootstrap here. */ 90 91 const double log10_2 = .30102999566398119521; 92 double log10_b; 93 const struct real_format *fmt; 94 95 char name[64], buf[128]; 96 int dig, min_10_exp, max_10_exp; 97 int decimal_dig; 98 99 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 100 gcc_assert (fmt->b != 10); 101 102 /* The radix of the exponent representation. */ 103 if (type == float_type_node) 104 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b); 105 log10_b = log10_2 * fmt->log2_b; 106 107 /* The number of radix digits, p, in the floating-point significand. */ 108 sprintf (name, "__%s_MANT_DIG__", name_prefix); 109 builtin_define_with_int_value (name, fmt->p); 110 111 /* The number of decimal digits, q, such that any floating-point number 112 with q decimal digits can be rounded into a floating-point number with 113 p radix b digits and back again without change to the q decimal digits, 114 115 p log10 b if b is a power of 10 116 floor((p - 1) log10 b) otherwise 117 */ 118 dig = (fmt->p - 1) * log10_b; 119 sprintf (name, "__%s_DIG__", name_prefix); 120 builtin_define_with_int_value (name, dig); 121 122 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 123 sprintf (name, "__%s_MIN_EXP__", name_prefix); 124 sprintf (buf, "(%d)", fmt->emin); 125 builtin_define_with_value (name, buf, 0); 126 127 /* The minimum negative int x such that 10**x is a normalized float, 128 129 ceil (log10 (b ** (emin - 1))) 130 = ceil (log10 (b) * (emin - 1)) 131 132 Recall that emin is negative, so the integer truncation calculates 133 the ceiling, not the floor, in this case. */ 134 min_10_exp = (fmt->emin - 1) * log10_b; 135 sprintf (name, "__%s_MIN_10_EXP__", name_prefix); 136 sprintf (buf, "(%d)", min_10_exp); 137 builtin_define_with_value (name, buf, 0); 138 139 /* The maximum int x such that b**(x-1) is a representable float. */ 140 sprintf (name, "__%s_MAX_EXP__", name_prefix); 141 builtin_define_with_int_value (name, fmt->emax); 142 143 /* The maximum int x such that 10**x is in the range of representable 144 finite floating-point numbers, 145 146 floor (log10((1 - b**-p) * b**emax)) 147 = floor (log10(1 - b**-p) + log10(b**emax)) 148 = floor (log10(1 - b**-p) + log10(b)*emax) 149 150 The safest thing to do here is to just compute this number. But since 151 we don't link cc1 with libm, we cannot. We could implement log10 here 152 a series expansion, but that seems too much effort because: 153 154 Note that the first term, for all extant p, is a number exceedingly close 155 to zero, but slightly negative. Note that the second term is an integer 156 scaling an irrational number, and that because of the floor we are only 157 interested in its integral portion. 158 159 In order for the first term to have any effect on the integral portion 160 of the second term, the second term has to be exceedingly close to an 161 integer itself (e.g. 123.000000000001 or something). Getting a result 162 that close to an integer requires that the irrational multiplicand have 163 a long series of zeros in its expansion, which doesn't occur in the 164 first 20 digits or so of log10(b). 165 166 Hand-waving aside, crunching all of the sets of constants above by hand 167 does not yield a case for which the first term is significant, which 168 in the end is all that matters. */ 169 max_10_exp = fmt->emax * log10_b; 170 sprintf (name, "__%s_MAX_10_EXP__", name_prefix); 171 builtin_define_with_int_value (name, max_10_exp); 172 173 /* The number of decimal digits, n, such that any floating-point number 174 can be rounded to n decimal digits and back again without change to 175 the value. 176 177 p * log10(b) if b is a power of 10 178 ceil(1 + p * log10(b)) otherwise 179 180 The only macro we care about is this number for the widest supported 181 floating type, but we want this value for rendering constants below. */ 182 { 183 double d_decimal_dig = 1 + fmt->p * log10_b; 184 decimal_dig = d_decimal_dig; 185 if (decimal_dig < d_decimal_dig) 186 decimal_dig++; 187 } 188 if (type == long_double_type_node) 189 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig); 190 191 /* Since, for the supported formats, B is always a power of 2, we 192 construct the following numbers directly as a hexadecimal 193 constants. */ 194 195 /* The maximum representable finite floating-point number, 196 (1 - b**-p) * b**emax */ 197 { 198 int i, n; 199 char *p; 200 201 strcpy (buf, "0x0."); 202 n = fmt->p * fmt->log2_b; 203 for (i = 0, p = buf + 4; i + 3 < n; i += 4) 204 *p++ = 'f'; 205 if (i < n) 206 *p++ = "08ce"[n - i]; 207 sprintf (p, "p%d", fmt->emax * fmt->log2_b); 208 if (fmt->pnan < fmt->p) 209 { 210 /* This is an IBM extended double format made up of two IEEE 211 doubles. The value of the long double is the sum of the 212 values of the two parts. The most significant part is 213 required to be the value of the long double rounded to the 214 nearest double. Rounding means we need a slightly smaller 215 value for LDBL_MAX. */ 216 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4]; 217 } 218 } 219 sprintf (name, "__%s_MAX__", name_prefix); 220 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 221 222 /* The minimum normalized positive floating-point number, 223 b**(emin-1). */ 224 sprintf (name, "__%s_MIN__", name_prefix); 225 sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b); 226 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 227 228 /* The difference between 1 and the least value greater than 1 that is 229 representable in the given floating point type, b**(1-p). */ 230 sprintf (name, "__%s_EPSILON__", name_prefix); 231 if (fmt->pnan < fmt->p) 232 /* This is an IBM extended double format, so 1.0 + any double is 233 representable precisely. */ 234 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b); 235 else 236 sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b); 237 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); 238 239 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized 240 positive floating-point number, b**(emin-p). Zero for formats that 241 don't support denormals. */ 242 sprintf (name, "__%s_DENORM_MIN__", name_prefix); 243 if (fmt->has_denorm) 244 { 245 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b); 246 builtin_define_with_hex_fp_value (name, type, decimal_dig, 247 buf, fp_suffix, fp_cast); 248 } 249 else 250 { 251 sprintf (buf, "0.0%s", fp_suffix); 252 builtin_define_with_value (name, buf, 0); 253 } 254 255 sprintf (name, "__%s_HAS_DENORM__", name_prefix); 256 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0); 257 258 /* For C++ std::numeric_limits<T>::has_infinity. */ 259 sprintf (name, "__%s_HAS_INFINITY__", name_prefix); 260 builtin_define_with_int_value (name, 261 MODE_HAS_INFINITIES (TYPE_MODE (type))); 262 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a 263 predicate to distinguish a target that has both quiet and 264 signalling NaNs from a target that has only quiet NaNs or only 265 signalling NaNs, so we assume that a target that has any kind of 266 NaN has quiet NaNs. */ 267 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix); 268 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type))); 269} 270 271/* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */ 272static void 273builtin_define_decimal_float_constants (const char *name_prefix, 274 const char *suffix, 275 tree type) 276{ 277 const struct real_format *fmt; 278 char name[64], buf[128], *p; 279 int digits; 280 281 fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); 282 283 /* The number of radix digits, p, in the significand. */ 284 sprintf (name, "__%s_MANT_DIG__", name_prefix); 285 builtin_define_with_int_value (name, fmt->p); 286 287 /* The minimum negative int x such that b**(x-1) is a normalized float. */ 288 sprintf (name, "__%s_MIN_EXP__", name_prefix); 289 sprintf (buf, "(%d)", fmt->emin); 290 builtin_define_with_value (name, buf, 0); 291 292 /* The maximum int x such that b**(x-1) is a representable float. */ 293 sprintf (name, "__%s_MAX_EXP__", name_prefix); 294 builtin_define_with_int_value (name, fmt->emax); 295 296 /* Compute the minimum representable value. */ 297 sprintf (name, "__%s_MIN__", name_prefix); 298 sprintf (buf, "1E%d%s", fmt->emin, suffix); 299 builtin_define_with_value (name, buf, 0); 300 301 /* Compute the maximum representable value. */ 302 sprintf (name, "__%s_MAX__", name_prefix); 303 p = buf; 304 for (digits = fmt->p; digits; digits--) 305 { 306 *p++ = '9'; 307 if (digits == fmt->p) 308 *p++ = '.'; 309 } 310 *p = 0; 311 /* fmt->p plus 1, to account for the decimal point. */ 312 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix); 313 builtin_define_with_value (name, buf, 0); 314 315 /* Compute epsilon (the difference between 1 and least value greater 316 than 1 representable). */ 317 sprintf (name, "__%s_EPSILON__", name_prefix); 318 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix); 319 builtin_define_with_value (name, buf, 0); 320 321 /* Minimum denormalized postive decimal value. */ 322 sprintf (name, "__%s_DEN__", name_prefix); 323 p = buf; 324 for (digits = fmt->p; digits > 1; digits--) 325 { 326 *p++ = '0'; 327 if (digits == fmt->p) 328 *p++ = '.'; 329 } 330 *p = 0; 331 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix); 332 builtin_define_with_value (name, buf, 0); 333} 334 335/* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */ 336static void 337define__GNUC__ (void) 338{ 339 /* The format of the version string, enforced below, is 340 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */ 341 const char *q, *v = version_string; 342 343 while (*v && !ISDIGIT (*v)) 344 v++; 345 gcc_assert (*v && (v <= version_string || v[-1] == '-')); 346 347 q = v; 348 while (ISDIGIT (*v)) 349 v++; 350 builtin_define_with_value_n ("__GNUC__", q, v - q); 351 if (c_dialect_cxx ()) 352 builtin_define_with_value_n ("__GNUG__", q, v - q); 353 354 gcc_assert (*v == '.' && ISDIGIT (v[1])); 355 356 q = ++v; 357 while (ISDIGIT (*v)) 358 v++; 359 builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q); 360 361 if (*v == '.') 362 { 363 gcc_assert (ISDIGIT (v[1])); 364 q = ++v; 365 while (ISDIGIT (*v)) 366 v++; 367 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q); 368 } 369 else 370 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1); 371 372 gcc_assert (!*v || *v == ' ' || *v == '-'); 373} 374 375/* Define macros used by <stdint.h>. Currently only defines limits 376 for intmax_t, used by the testsuite. */ 377static void 378builtin_define_stdint_macros (void) 379{ 380 int intmax_long; 381 if (intmax_type_node == long_long_integer_type_node) 382 intmax_long = 2; 383 else if (intmax_type_node == long_integer_type_node) 384 intmax_long = 1; 385 else if (intmax_type_node == integer_type_node) 386 intmax_long = 0; 387 else 388 gcc_unreachable (); 389 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long); 390} 391 392/* Hook that registers front end and target-specific built-ins. */ 393void 394c_cpp_builtins (cpp_reader *pfile) 395{ 396 /* -undef turns off target-specific built-ins. */ 397 if (flag_undef) 398 return; 399 400 define__GNUC__ (); 401 402 /* For stddef.h. They require macros defined in c-common.c. */ 403 c_stddef_cpp_builtins (); 404 405 if (c_dialect_cxx ()) 406 { 407 if (flag_weak && SUPPORTS_ONE_ONLY) 408 cpp_define (pfile, "__GXX_WEAK__=1"); 409 else 410 cpp_define (pfile, "__GXX_WEAK__=0"); 411 if (warn_deprecated) 412 cpp_define (pfile, "__DEPRECATED"); 413 } 414 /* Note that we define this for C as well, so that we know if 415 __attribute__((cleanup)) will interface with EH. */ 416 if (flag_exceptions) 417 cpp_define (pfile, "__EXCEPTIONS"); 418 419 /* Represents the C++ ABI version, always defined so it can be used while 420 preprocessing C and assembler. */ 421 if (flag_abi_version == 0) 422 /* Use a very large value so that: 423 424 #if __GXX_ABI_VERSION >= <value for version X> 425 426 will work whether the user explicitly says "-fabi-version=x" or 427 "-fabi-version=0". Do not use INT_MAX because that will be 428 different from system to system. */ 429 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); 430 else if (flag_abi_version == 1) 431 /* Due to a historical accident, this version had the value 432 "102". */ 433 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); 434 else 435 /* Newer versions have values 1002, 1003, .... */ 436 builtin_define_with_int_value ("__GXX_ABI_VERSION", 437 1000 + flag_abi_version); 438 439 /* libgcc needs to know this. */ 440 if (USING_SJLJ_EXCEPTIONS) 441 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); 442 443 /* limits.h needs to know these. */ 444 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0); 445 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0); 446 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0); 447 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1); 448 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2); 449 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0); 450 451 builtin_define_type_precision ("__CHAR_BIT__", char_type_node); 452 453 /* stdint.h (eventually) and the testsuite need to know these. */ 454 builtin_define_stdint_macros (); 455 456 /* float.h needs to know these. */ 457 458 builtin_define_with_int_value ("__FLT_EVAL_METHOD__", 459 TARGET_FLT_EVAL_METHOD); 460 461 /* And decfloat.h needs this. */ 462 builtin_define_with_int_value ("__DEC_EVAL_METHOD__", 463 TARGET_DEC_EVAL_METHOD); 464 465 builtin_define_float_constants ("FLT", "F", "%s", float_type_node); 466 /* Cast the double precision constants when single precision constants are 467 specified. The correct result is computed by the compiler when using 468 macros that include a cast. This has the side-effect of making the value 469 unusable in const expressions. */ 470 if (flag_single_precision_constant) 471 builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); 472 else 473 builtin_define_float_constants ("DBL", "", "%s", double_type_node); 474 builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); 475 476 /* For decfloat.h. */ 477 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node); 478 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node); 479 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node); 480 481 /* For use in assembly language. */ 482 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); 483 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); 484 485 /* Misc. */ 486 builtin_define_with_value ("__VERSION__", version_string, 1); 487 488 if (flag_gnu89_inline) 489 cpp_define (pfile, "__GNUC_GNU_INLINE__"); 490 else 491 cpp_define (pfile, "__GNUC_STDC_INLINE__"); 492 493 /* Definitions for LP64 model. */ 494 if (TYPE_PRECISION (long_integer_type_node) == 64 495 && POINTER_SIZE == 64 496 && TYPE_PRECISION (integer_type_node) == 32) 497 { 498 cpp_define (pfile, "_LP64"); 499 cpp_define (pfile, "__LP64__"); 500 } 501 502 /* Other target-independent built-ins determined by command-line 503 options. */ 504 /* APPLE LOCAL begin blocks */ 505 /* APPLE LOCAL radar 5868913 */ 506 if (flag_blocks) 507 { 508 cpp_define (pfile, "__block=__attribute__((__blocks__(byref)))"); 509 cpp_define (pfile, "__BLOCKS__=1"); 510 } 511 /* APPLE LOCAL end blocks */ 512 if (optimize_size) 513 cpp_define (pfile, "__OPTIMIZE_SIZE__"); 514 if (optimize) 515 cpp_define (pfile, "__OPTIMIZE__"); 516 517 if (fast_math_flags_set_p ()) 518 cpp_define (pfile, "__FAST_MATH__"); 519 if (flag_really_no_inline) 520 cpp_define (pfile, "__NO_INLINE__"); 521 if (flag_signaling_nans) 522 cpp_define (pfile, "__SUPPORT_SNAN__"); 523 if (flag_finite_math_only) 524 cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); 525 else 526 cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); 527 if (flag_pic) 528 { 529 builtin_define_with_int_value ("__pic__", flag_pic); 530 builtin_define_with_int_value ("__PIC__", flag_pic); 531 } 532 533 if (flag_iso) 534 cpp_define (pfile, "__STRICT_ANSI__"); 535 536 if (!flag_signed_char) 537 cpp_define (pfile, "__CHAR_UNSIGNED__"); 538 539 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) 540 cpp_define (pfile, "__WCHAR_UNSIGNED__"); 541 542 /* Make the choice of ObjC runtime visible to source code. */ 543 if (c_dialect_objc () && flag_next_runtime) 544 cpp_define (pfile, "__NEXT_RUNTIME__"); 545 546 /* Show the availability of some target pragmas. */ 547 if (flag_mudflap || targetm.handle_pragma_redefine_extname) 548 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); 549 550 if (targetm.handle_pragma_extern_prefix) 551 cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX"); 552 553 /* Make the choice of the stack protector runtime visible to source code. 554 The macro names and values here were chosen for compatibility with an 555 earlier implementation, i.e. ProPolice. */ 556 if (flag_stack_protect == 2) 557 cpp_define (pfile, "__SSP_ALL__=2"); 558 else if (flag_stack_protect == 1) 559 cpp_define (pfile, "__SSP__=1"); 560 561 if (flag_openmp) 562 cpp_define (pfile, "_OPENMP=200505"); 563 564 /* A straightforward target hook doesn't work, because of problems 565 linking that hook's body when part of non-C front ends. */ 566# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) 567# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) 568# define builtin_define(TXT) cpp_define (pfile, TXT) 569# define builtin_assert(TXT) cpp_assert (pfile, TXT) 570 TARGET_CPU_CPP_BUILTINS (); 571 TARGET_OS_CPP_BUILTINS (); 572 TARGET_OBJFMT_CPP_BUILTINS (); 573 574 /* Support the __declspec keyword by turning them into attributes. 575 Note that the current way we do this may result in a collision 576 with predefined attributes later on. This can be solved by using 577 one attribute, say __declspec__, and passing args to it. The 578 problem with that approach is that args are not accumulated: each 579 new appearance would clobber any existing args. */ 580 if (TARGET_DECLSPEC) 581 builtin_define ("__declspec(x)=__attribute__((x))"); 582} 583 584/* Pass an object-like macro. If it doesn't lie in the user's 585 namespace, defines it unconditionally. Otherwise define a version 586 with two leading underscores, and another version with two leading 587 and trailing underscores, and define the original only if an ISO 588 standard was not nominated. 589 590 e.g. passing "unix" defines "__unix", "__unix__" and possibly 591 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly 592 "_mips". */ 593void 594builtin_define_std (const char *macro) 595{ 596 size_t len = strlen (macro); 597 char *buff = (char *) alloca (len + 5); 598 char *p = buff + 2; 599 char *q = p + len; 600 601 /* prepend __ (or maybe just _) if in user's namespace. */ 602 memcpy (p, macro, len + 1); 603 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) 604 { 605 if (*p != '_') 606 *--p = '_'; 607 if (p[1] != '_') 608 *--p = '_'; 609 } 610 cpp_define (parse_in, p); 611 612 /* If it was in user's namespace... */ 613 if (p != buff + 2) 614 { 615 /* Define the macro with leading and following __. */ 616 if (q[-1] != '_') 617 *q++ = '_'; 618 if (q[-2] != '_') 619 *q++ = '_'; 620 *q = '\0'; 621 cpp_define (parse_in, p); 622 623 /* Finally, define the original macro if permitted. */ 624 if (!flag_iso) 625 cpp_define (parse_in, macro); 626 } 627} 628 629/* Pass an object-like macro and a value to define it to. The third 630 parameter says whether or not to turn the value into a string 631 constant. */ 632void 633builtin_define_with_value (const char *macro, const char *expansion, int is_str) 634{ 635 char *buf; 636 size_t mlen = strlen (macro); 637 size_t elen = strlen (expansion); 638 size_t extra = 2; /* space for an = and a NUL */ 639 640 if (is_str) 641 extra += 2; /* space for two quote marks */ 642 643 buf = (char *) alloca (mlen + elen + extra); 644 if (is_str) 645 sprintf (buf, "%s=\"%s\"", macro, expansion); 646 else 647 sprintf (buf, "%s=%s", macro, expansion); 648 649 cpp_define (parse_in, buf); 650} 651 652/* Pass an object-like macro and a value to define it to. The third 653 parameter is the length of the expansion. */ 654static void 655builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen) 656{ 657 char *buf; 658 size_t mlen = strlen (macro); 659 660 /* Space for an = and a NUL. */ 661 buf = (char *) alloca (mlen + elen + 2); 662 memcpy (buf, macro, mlen); 663 buf[mlen] = '='; 664 memcpy (buf + mlen + 1, expansion, elen); 665 buf[mlen + elen + 1] = '\0'; 666 667 cpp_define (parse_in, buf); 668} 669 670/* Pass an object-like macro and an integer value to define it to. */ 671static void 672builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 673{ 674 char *buf; 675 size_t mlen = strlen (macro); 676 size_t vlen = 18; 677 size_t extra = 2; /* space for = and NUL. */ 678 679 buf = (char *) alloca (mlen + vlen + extra); 680 memcpy (buf, macro, mlen); 681 buf[mlen] = '='; 682 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); 683 684 cpp_define (parse_in, buf); 685} 686 687/* Pass an object-like macro a hexadecimal floating-point value. */ 688static void 689builtin_define_with_hex_fp_value (const char *macro, 690 tree type ATTRIBUTE_UNUSED, int digits, 691 const char *hex_str, 692 const char *fp_suffix, 693 const char *fp_cast) 694{ 695 REAL_VALUE_TYPE real; 696 char dec_str[64], buf1[256], buf2[256]; 697 698 /* Hex values are really cool and convenient, except that they're 699 not supported in strict ISO C90 mode. First, the "p-" sequence 700 is not valid as part of a preprocessor number. Second, we get a 701 pedwarn from the preprocessor, which has no context, so we can't 702 suppress the warning with __extension__. 703 704 So instead what we do is construct the number in hex (because 705 it's easy to get the exact correct value), parse it as a real, 706 then print it back out as decimal. */ 707 708 real_from_string (&real, hex_str); 709 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0); 710 711 /* Assemble the macro in the following fashion 712 macro = fp_cast [dec_str fp_suffix] */ 713 sprintf (buf1, "%s%s", dec_str, fp_suffix); 714 sprintf (buf2, fp_cast, buf1); 715 sprintf (buf1, "%s=%s", macro, buf2); 716 717 cpp_define (parse_in, buf1); 718} 719 720/* Define MAX for TYPE based on the precision of the type. IS_LONG is 721 1 for type "long" and 2 for "long long". We have to handle 722 unsigned types, since wchar_t might be unsigned. */ 723 724static void 725builtin_define_type_max (const char *macro, tree type, int is_long) 726{ 727 static const char *const values[] 728 = { "127", "255", 729 "32767", "65535", 730 "2147483647", "4294967295", 731 "9223372036854775807", "18446744073709551615", 732 "170141183460469231731687303715884105727", 733 "340282366920938463463374607431768211455" }; 734 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; 735 736 const char *value, *suffix; 737 char *buf; 738 size_t idx; 739 740 /* Pre-rendering the values mean we don't have to futz with printing a 741 multi-word decimal value. There are also a very limited number of 742 precisions that we support, so it's really a waste of time. */ 743 switch (TYPE_PRECISION (type)) 744 { 745 case 8: idx = 0; break; 746 case 16: idx = 2; break; 747 case 32: idx = 4; break; 748 case 64: idx = 6; break; 749 case 128: idx = 8; break; 750 default: gcc_unreachable (); 751 } 752 753 value = values[idx + TYPE_UNSIGNED (type)]; 754 suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)]; 755 756 buf = (char *) alloca (strlen (macro) + 1 + strlen (value) 757 + strlen (suffix) + 1); 758 sprintf (buf, "%s=%s%s", macro, value, suffix); 759 760 cpp_define (parse_in, buf); 761} 762