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