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.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 #include "coretypes.h"
33 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
35 #include "tm_p.h" /* Target prototypes. */
38 #ifndef TARGET_OS_CPP_BUILTINS
39 # define TARGET_OS_CPP_BUILTINS()
42 #ifndef TARGET_OBJFMT_CPP_BUILTINS
43 # define TARGET_OBJFMT_CPP_BUILTINS()
46 #ifndef REGISTER_PREFIX
47 #define REGISTER_PREFIX ""
50 /* Non-static as some targets don't use it. */
51 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
52 static void builtin_define_with_value_n (const char *, const char *,
54 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
55 static void builtin_define_with_hex_fp_value (const char *, tree,
59 static void builtin_define_stdint_macros (void);
60 static void builtin_define_type_max (const char *, tree, int);
61 static void builtin_define_type_precision (const char *, tree);
62 static void builtin_define_float_constants (const char *,
66 static void define__GNUC__ (void);
68 /* Define NAME with value TYPE precision. */
70 builtin_define_type_precision (const char *name, tree type)
72 builtin_define_with_int_value (name, TYPE_PRECISION (type));
75 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
78 builtin_define_float_constants (const char *name_prefix,
79 const char *fp_suffix,
83 /* Used to convert radix-based values to base 10 values in several cases.
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. */
91 const double log10_2 = .30102999566398119521;
93 const struct real_format *fmt;
95 char name[64], buf[128];
96 int dig, min_10_exp, max_10_exp;
99 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
100 gcc_assert (fmt->b != 10);
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;
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);
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,
115 p log10 b if b is a power of 10
116 floor((p - 1) log10 b) otherwise
118 dig = (fmt->p - 1) * log10_b;
119 sprintf (name, "__%s_DIG__", name_prefix);
120 builtin_define_with_int_value (name, dig);
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);
127 /* The minimum negative int x such that 10**x is a normalized float,
129 ceil (log10 (b ** (emin - 1)))
130 = ceil (log10 (b) * (emin - 1))
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);
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);
143 /* The maximum int x such that 10**x is in the range of representable
144 finite floating-point numbers,
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)
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:
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.
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).
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);
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
177 p * log10(b) if b is a power of 10
178 ceil(1 + p * log10(b)) otherwise
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. */
183 double d_decimal_dig = 1 + fmt->p * log10_b;
184 decimal_dig = d_decimal_dig;
185 if (decimal_dig < d_decimal_dig)
188 if (type == long_double_type_node)
189 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
191 /* Since, for the supported formats, B is always a power of 2, we
192 construct the following numbers directly as a hexadecimal
195 /* The maximum representable finite floating-point number,
196 (1 - b**-p) * b**emax */
201 strcpy (buf, "0x0.");
202 n = fmt->p * fmt->log2_b;
203 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
206 *p++ = "08ce"[n - i];
207 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
208 if (fmt->pnan < fmt->p)
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];
219 sprintf (name, "__%s_MAX__", name_prefix);
220 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
222 /* The minimum normalized positive floating-point number,
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);
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);
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);
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);
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);
251 sprintf (buf, "0.0%s", fp_suffix);
252 builtin_define_with_value (name, buf, 0);
255 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
256 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
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)));
271 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
273 builtin_define_decimal_float_constants (const char *name_prefix,
277 const struct real_format *fmt;
278 char name[64], buf[128], *p;
281 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
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);
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);
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);
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);
301 /* Compute the maximum representable value. */
302 sprintf (name, "__%s_MAX__", name_prefix);
304 for (digits = fmt->p; digits; digits--)
307 if (digits == fmt->p)
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);
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);
321 /* Minimum denormalized postive decimal value. */
322 sprintf (name, "__%s_DEN__", name_prefix);
324 for (digits = fmt->p; digits > 1; digits--)
327 if (digits == fmt->p)
331 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
332 builtin_define_with_value (name, buf, 0);
335 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
337 define__GNUC__ (void)
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;
343 while (*v && !ISDIGIT (*v))
345 gcc_assert (*v && (v <= version_string || v[-1] == '-'));
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);
354 gcc_assert (*v == '.' && ISDIGIT (v[1]));
359 builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
363 gcc_assert (ISDIGIT (v[1]));
367 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
370 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
372 gcc_assert (!*v || *v == ' ' || *v == '-');
375 /* Define macros used by <stdint.h>. Currently only defines limits
376 for intmax_t, used by the testsuite. */
378 builtin_define_stdint_macros (void)
381 if (intmax_type_node == long_long_integer_type_node)
383 else if (intmax_type_node == long_integer_type_node)
385 else if (intmax_type_node == integer_type_node)
389 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
392 /* Hook that registers front end and target-specific built-ins. */
394 c_cpp_builtins (cpp_reader *pfile)
396 /* -undef turns off target-specific built-ins. */
402 /* For stddef.h. They require macros defined in c-common.c. */
403 c_stddef_cpp_builtins ();
405 if (c_dialect_cxx ())
407 if (flag_weak && SUPPORTS_ONE_ONLY)
408 cpp_define (pfile, "__GXX_WEAK__=1");
410 cpp_define (pfile, "__GXX_WEAK__=0");
412 cpp_define (pfile, "__DEPRECATED");
414 /* Note that we define this for C as well, so that we know if
415 __attribute__((cleanup)) will interface with EH. */
417 cpp_define (pfile, "__EXCEPTIONS");
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:
424 #if __GXX_ABI_VERSION >= <value for version X>
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
433 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
435 /* Newer versions have values 1002, 1003, .... */
436 builtin_define_with_int_value ("__GXX_ABI_VERSION",
437 1000 + flag_abi_version);
439 /* libgcc needs to know this. */
440 if (USING_SJLJ_EXCEPTIONS)
441 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
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);
451 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
453 /* stdint.h (eventually) and the testsuite need to know these. */
454 builtin_define_stdint_macros ();
456 /* float.h needs to know these. */
458 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
459 TARGET_FLT_EVAL_METHOD);
461 /* And decfloat.h needs this. */
462 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
463 TARGET_DEC_EVAL_METHOD);
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);
473 builtin_define_float_constants ("DBL", "", "%s", double_type_node);
474 builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
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);
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);
486 builtin_define_with_value ("__VERSION__", version_string, 1);
488 if (flag_gnu89_inline)
489 cpp_define (pfile, "__GNUC_GNU_INLINE__");
491 cpp_define (pfile, "__GNUC_STDC_INLINE__");
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)
498 cpp_define (pfile, "_LP64");
499 cpp_define (pfile, "__LP64__");
502 /* Other target-independent built-ins determined by command-line
505 cpp_define (pfile, "__OPTIMIZE_SIZE__");
507 cpp_define (pfile, "__OPTIMIZE__");
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");
518 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
521 builtin_define_with_int_value ("__pic__", flag_pic);
522 builtin_define_with_int_value ("__PIC__", flag_pic);
526 cpp_define (pfile, "__STRICT_ANSI__");
528 if (!flag_signed_char)
529 cpp_define (pfile, "__CHAR_UNSIGNED__");
531 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
532 cpp_define (pfile, "__WCHAR_UNSIGNED__");
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__");
538 /* Show the availability of some target pragmas. */
539 if (flag_mudflap || targetm.handle_pragma_redefine_extname)
540 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
542 if (targetm.handle_pragma_extern_prefix)
543 cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
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");
554 cpp_define (pfile, "_OPENMP=200505");
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 ();
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. */
573 builtin_define ("__declspec(x)=__attribute__((x))");
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.
582 e.g. passing "unix" defines "__unix", "__unix__" and possibly
583 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
586 builtin_define_std (const char *macro)
588 size_t len = strlen (macro);
589 char *buff = (char *) alloca (len + 5);
593 /* prepend __ (or maybe just _) if in user's namespace. */
594 memcpy (p, macro, len + 1);
595 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
602 cpp_define (parse_in, p);
604 /* If it was in user's namespace... */
607 /* Define the macro with leading and following __. */
613 cpp_define (parse_in, p);
615 /* Finally, define the original macro if permitted. */
617 cpp_define (parse_in, macro);
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
625 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
628 size_t mlen = strlen (macro);
629 size_t elen = strlen (expansion);
630 size_t extra = 2; /* space for an = and a NUL */
633 extra += 2; /* space for two quote marks */
635 buf = (char *) alloca (mlen + elen + extra);
637 sprintf (buf, "%s=\"%s\"", macro, expansion);
639 sprintf (buf, "%s=%s", macro, expansion);
641 cpp_define (parse_in, buf);
644 /* Pass an object-like macro and a value to define it to. The third
645 parameter is the length of the expansion. */
647 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
650 size_t mlen = strlen (macro);
652 /* Space for an = and a NUL. */
653 buf = (char *) alloca (mlen + elen + 2);
654 memcpy (buf, macro, mlen);
656 memcpy (buf + mlen + 1, expansion, elen);
657 buf[mlen + elen + 1] = '\0';
659 cpp_define (parse_in, buf);
662 /* Pass an object-like macro and an integer value to define it to. */
664 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
667 size_t mlen = strlen (macro);
669 size_t extra = 2; /* space for = and NUL. */
671 buf = (char *) alloca (mlen + vlen + extra);
672 memcpy (buf, macro, mlen);
674 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
676 cpp_define (parse_in, buf);
679 /* Pass an object-like macro a hexadecimal floating-point value. */
681 builtin_define_with_hex_fp_value (const char *macro,
682 tree type ATTRIBUTE_UNUSED, int digits,
684 const char *fp_suffix,
687 REAL_VALUE_TYPE real;
688 char dec_str[64], buf1[256], buf2[256];
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__.
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. */
700 real_from_string (&real, hex_str);
701 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
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);
709 cpp_define (parse_in, buf1);
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. */
717 builtin_define_type_max (const char *macro, tree type, int is_long)
719 static const char *const values[]
722 "2147483647", "4294967295",
723 "9223372036854775807", "18446744073709551615",
724 "170141183460469231731687303715884105727",
725 "340282366920938463463374607431768211455" };
726 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
728 const char *value, *suffix;
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))
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 ();
745 value = values[idx + TYPE_UNSIGNED (type)];
746 suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
748 buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
749 + strlen (suffix) + 1);
750 sprintf (buf, "%s=%s%s", macro, value, suffix);
752 cpp_define (parse_in, buf);