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