c-cppbuiltin.c revision 286713
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 == 3) 557 cpp_define (pfile, "__SSP_STRONG__=3"); 558 else if (flag_stack_protect == 2) 559 cpp_define (pfile, "__SSP_ALL__=2"); 560 else if (flag_stack_protect == 1) 561 cpp_define (pfile, "__SSP__=1"); 562 563 if (flag_openmp) 564 cpp_define (pfile, "_OPENMP=200505"); 565 566 /* A straightforward target hook doesn't work, because of problems 567 linking that hook's body when part of non-C front ends. */ 568# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) 569# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) 570# define builtin_define(TXT) cpp_define (pfile, TXT) 571# define builtin_assert(TXT) cpp_assert (pfile, TXT) 572 TARGET_CPU_CPP_BUILTINS (); 573 TARGET_OS_CPP_BUILTINS (); 574 TARGET_OBJFMT_CPP_BUILTINS (); 575 576 /* Support the __declspec keyword by turning them into attributes. 577 Note that the current way we do this may result in a collision 578 with predefined attributes later on. This can be solved by using 579 one attribute, say __declspec__, and passing args to it. The 580 problem with that approach is that args are not accumulated: each 581 new appearance would clobber any existing args. */ 582 if (TARGET_DECLSPEC) 583 builtin_define ("__declspec(x)=__attribute__((x))"); 584} 585 586/* Pass an object-like macro. If it doesn't lie in the user's 587 namespace, defines it unconditionally. Otherwise define a version 588 with two leading underscores, and another version with two leading 589 and trailing underscores, and define the original only if an ISO 590 standard was not nominated. 591 592 e.g. passing "unix" defines "__unix", "__unix__" and possibly 593 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly 594 "_mips". */ 595void 596builtin_define_std (const char *macro) 597{ 598 size_t len = strlen (macro); 599 char *buff = (char *) alloca (len + 5); 600 char *p = buff + 2; 601 char *q = p + len; 602 603 /* prepend __ (or maybe just _) if in user's namespace. */ 604 memcpy (p, macro, len + 1); 605 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) 606 { 607 if (*p != '_') 608 *--p = '_'; 609 if (p[1] != '_') 610 *--p = '_'; 611 } 612 cpp_define (parse_in, p); 613 614 /* If it was in user's namespace... */ 615 if (p != buff + 2) 616 { 617 /* Define the macro with leading and following __. */ 618 if (q[-1] != '_') 619 *q++ = '_'; 620 if (q[-2] != '_') 621 *q++ = '_'; 622 *q = '\0'; 623 cpp_define (parse_in, p); 624 625 /* Finally, define the original macro if permitted. */ 626 if (!flag_iso) 627 cpp_define (parse_in, macro); 628 } 629} 630 631/* Pass an object-like macro and a value to define it to. The third 632 parameter says whether or not to turn the value into a string 633 constant. */ 634void 635builtin_define_with_value (const char *macro, const char *expansion, int is_str) 636{ 637 char *buf; 638 size_t mlen = strlen (macro); 639 size_t elen = strlen (expansion); 640 size_t extra = 2; /* space for an = and a NUL */ 641 642 if (is_str) 643 extra += 2; /* space for two quote marks */ 644 645 buf = (char *) alloca (mlen + elen + extra); 646 if (is_str) 647 sprintf (buf, "%s=\"%s\"", macro, expansion); 648 else 649 sprintf (buf, "%s=%s", macro, expansion); 650 651 cpp_define (parse_in, buf); 652} 653 654/* Pass an object-like macro and a value to define it to. The third 655 parameter is the length of the expansion. */ 656static void 657builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen) 658{ 659 char *buf; 660 size_t mlen = strlen (macro); 661 662 /* Space for an = and a NUL. */ 663 buf = (char *) alloca (mlen + elen + 2); 664 memcpy (buf, macro, mlen); 665 buf[mlen] = '='; 666 memcpy (buf + mlen + 1, expansion, elen); 667 buf[mlen + elen + 1] = '\0'; 668 669 cpp_define (parse_in, buf); 670} 671 672/* Pass an object-like macro and an integer value to define it to. */ 673static void 674builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) 675{ 676 char *buf; 677 size_t mlen = strlen (macro); 678 size_t vlen = 18; 679 size_t extra = 2; /* space for = and NUL. */ 680 681 buf = (char *) alloca (mlen + vlen + extra); 682 memcpy (buf, macro, mlen); 683 buf[mlen] = '='; 684 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); 685 686 cpp_define (parse_in, buf); 687} 688 689/* Pass an object-like macro a hexadecimal floating-point value. */ 690static void 691builtin_define_with_hex_fp_value (const char *macro, 692 tree type ATTRIBUTE_UNUSED, int digits, 693 const char *hex_str, 694 const char *fp_suffix, 695 const char *fp_cast) 696{ 697 REAL_VALUE_TYPE real; 698 char dec_str[64], buf1[256], buf2[256]; 699 700 /* Hex values are really cool and convenient, except that they're 701 not supported in strict ISO C90 mode. First, the "p-" sequence 702 is not valid as part of a preprocessor number. Second, we get a 703 pedwarn from the preprocessor, which has no context, so we can't 704 suppress the warning with __extension__. 705 706 So instead what we do is construct the number in hex (because 707 it's easy to get the exact correct value), parse it as a real, 708 then print it back out as decimal. */ 709 710 real_from_string (&real, hex_str); 711 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0); 712 713 /* Assemble the macro in the following fashion 714 macro = fp_cast [dec_str fp_suffix] */ 715 sprintf (buf1, "%s%s", dec_str, fp_suffix); 716 sprintf (buf2, fp_cast, buf1); 717 sprintf (buf1, "%s=%s", macro, buf2); 718 719 cpp_define (parse_in, buf1); 720} 721 722/* Define MAX for TYPE based on the precision of the type. IS_LONG is 723 1 for type "long" and 2 for "long long". We have to handle 724 unsigned types, since wchar_t might be unsigned. */ 725 726static void 727builtin_define_type_max (const char *macro, tree type, int is_long) 728{ 729 static const char *const values[] 730 = { "127", "255", 731 "32767", "65535", 732 "2147483647", "4294967295", 733 "9223372036854775807", "18446744073709551615", 734 "170141183460469231731687303715884105727", 735 "340282366920938463463374607431768211455" }; 736 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; 737 738 const char *value, *suffix; 739 char *buf; 740 size_t idx; 741 742 /* Pre-rendering the values mean we don't have to futz with printing a 743 multi-word decimal value. There are also a very limited number of 744 precisions that we support, so it's really a waste of time. */ 745 switch (TYPE_PRECISION (type)) 746 { 747 case 8: idx = 0; break; 748 case 16: idx = 2; break; 749 case 32: idx = 4; break; 750 case 64: idx = 6; break; 751 case 128: idx = 8; break; 752 default: gcc_unreachable (); 753 } 754 755 value = values[idx + TYPE_UNSIGNED (type)]; 756 suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)]; 757 758 buf = (char *) alloca (strlen (macro) + 1 + strlen (value) 759 + strlen (suffix) + 1); 760 sprintf (buf, "%s=%s%s", macro, value, suffix); 761 762 cpp_define (parse_in, buf); 763} 764