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