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