OSDN Git Service

Document compatibility with earlier ProPolice implementation.
[pf3gnuchains/gcc-fork.git] / gcc / c-cppbuiltin.c
1 /* Define builtin-in macros for the C family front ends.
2    Copyright (C) 2002, 2003, 2004, 2005 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, 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-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.  */
50 void builtin_define_std (const char *) ATTRIBUTE_UNUSED;
51 static void builtin_define_with_value_n (const char *, const char *,
52                                          size_t);
53 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
54 static void builtin_define_with_hex_fp_value (const char *, tree,
55                                               int, const char *,
56                                               const char *);
57 static void builtin_define_stdint_macros (void);
58 static void builtin_define_type_max (const char *, tree, int);
59 static void builtin_define_type_precision (const char *, tree);
60 static void builtin_define_float_constants (const char *, const char *,
61                                             tree);
62 static void define__GNUC__ (void);
63
64 /* Define NAME with value TYPE precision.  */
65 static void
66 builtin_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.  */
72 static void
73 builtin_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__.  */
260 static void
261 define__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.  */
301 static void
302 builtin_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.  */
317 void
318 c_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   /* Definitions for LP64 model.  */
397   if (TYPE_PRECISION (long_integer_type_node) == 64
398       && POINTER_SIZE == 64
399       && TYPE_PRECISION (integer_type_node) == 32)
400     {
401       cpp_define (pfile, "_LP64");
402       cpp_define (pfile, "__LP64__");
403     }
404
405   /* Other target-independent built-ins determined by command-line
406      options.  */
407   if (optimize_size)
408     cpp_define (pfile, "__OPTIMIZE_SIZE__");
409   if (optimize)
410     cpp_define (pfile, "__OPTIMIZE__");
411
412   if (fast_math_flags_set_p ())
413     cpp_define (pfile, "__FAST_MATH__");
414   if (flag_really_no_inline)
415     cpp_define (pfile, "__NO_INLINE__");
416   if (flag_signaling_nans)
417     cpp_define (pfile, "__SUPPORT_SNAN__");
418   if (flag_finite_math_only)
419     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
420   else
421     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
422
423   if (flag_iso)
424     cpp_define (pfile, "__STRICT_ANSI__");
425
426   if (!flag_signed_char)
427     cpp_define (pfile, "__CHAR_UNSIGNED__");
428
429   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
430     cpp_define (pfile, "__WCHAR_UNSIGNED__");
431
432   /* Make the choice of ObjC runtime visible to source code.  */
433   if (c_dialect_objc () && flag_next_runtime)
434     cpp_define (pfile, "__NEXT_RUNTIME__");
435
436   /* Show the availability of some target pragmas.  */
437   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
438     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
439
440   if (targetm.handle_pragma_extern_prefix)
441     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
442
443   /* Make the choice of the stack protector runtime visible to source code.
444      The macro names and values here were chosen for compatibility with an
445      earlier implementation, i.e. ProPolice.  */
446   if (flag_stack_protect == 2)
447     cpp_define (pfile, "__SSP_ALL__=2");
448   else if (flag_stack_protect == 1)
449     cpp_define (pfile, "__SSP__=1");
450
451   /* A straightforward target hook doesn't work, because of problems
452      linking that hook's body when part of non-C front ends.  */
453 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
454 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
455 # define builtin_define(TXT) cpp_define (pfile, TXT)
456 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
457   TARGET_CPU_CPP_BUILTINS ();
458   TARGET_OS_CPP_BUILTINS ();
459   TARGET_OBJFMT_CPP_BUILTINS ();
460
461   /* Support the __declspec keyword by turning them into attributes.
462      Note that the current way we do this may result in a collision
463      with predefined attributes later on.  This can be solved by using
464      one attribute, say __declspec__, and passing args to it.  The
465      problem with that approach is that args are not accumulated: each
466      new appearance would clobber any existing args.  */
467   if (TARGET_DECLSPEC)
468     builtin_define ("__declspec(x)=__attribute__((x))");
469 }
470
471 /* Pass an object-like macro.  If it doesn't lie in the user's
472    namespace, defines it unconditionally.  Otherwise define a version
473    with two leading underscores, and another version with two leading
474    and trailing underscores, and define the original only if an ISO
475    standard was not nominated.
476
477    e.g. passing "unix" defines "__unix", "__unix__" and possibly
478    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
479    "_mips".  */
480 void
481 builtin_define_std (const char *macro)
482 {
483   size_t len = strlen (macro);
484   char *buff = alloca (len + 5);
485   char *p = buff + 2;
486   char *q = p + len;
487
488   /* prepend __ (or maybe just _) if in user's namespace.  */
489   memcpy (p, macro, len + 1);
490   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
491     {
492       if (*p != '_')
493         *--p = '_';
494       if (p[1] != '_')
495         *--p = '_';
496     }
497   cpp_define (parse_in, p);
498
499   /* If it was in user's namespace...  */
500   if (p != buff + 2)
501     {
502       /* Define the macro with leading and following __.  */
503       if (q[-1] != '_')
504         *q++ = '_';
505       if (q[-2] != '_')
506         *q++ = '_';
507       *q = '\0';
508       cpp_define (parse_in, p);
509
510       /* Finally, define the original macro if permitted.  */
511       if (!flag_iso)
512         cpp_define (parse_in, macro);
513     }
514 }
515
516 /* Pass an object-like macro and a value to define it to.  The third
517    parameter says whether or not to turn the value into a string
518    constant.  */
519 void
520 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
521 {
522   char *buf;
523   size_t mlen = strlen (macro);
524   size_t elen = strlen (expansion);
525   size_t extra = 2;  /* space for an = and a NUL */
526
527   if (is_str)
528     extra += 2;  /* space for two quote marks */
529
530   buf = alloca (mlen + elen + extra);
531   if (is_str)
532     sprintf (buf, "%s=\"%s\"", macro, expansion);
533   else
534     sprintf (buf, "%s=%s", macro, expansion);
535
536   cpp_define (parse_in, buf);
537 }
538
539 /* Pass an object-like macro and a value to define it to.  The third
540    parameter is the length of the expansion.  */
541 static void
542 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
543 {
544   char *buf;
545   size_t mlen = strlen (macro);
546
547   /* Space for an = and a NUL.  */
548   buf = alloca (mlen + elen + 2);
549   memcpy (buf, macro, mlen);
550   buf[mlen] = '=';
551   memcpy (buf + mlen + 1, expansion, elen);
552   buf[mlen + elen + 1] = '\0';
553
554   cpp_define (parse_in, buf);
555 }
556
557 /* Pass an object-like macro and an integer value to define it to.  */
558 static void
559 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
560 {
561   char *buf;
562   size_t mlen = strlen (macro);
563   size_t vlen = 18;
564   size_t extra = 2; /* space for = and NUL.  */
565
566   buf = alloca (mlen + vlen + extra);
567   memcpy (buf, macro, mlen);
568   buf[mlen] = '=';
569   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
570
571   cpp_define (parse_in, buf);
572 }
573
574 /* Pass an object-like macro a hexadecimal floating-point value.  */
575 static void
576 builtin_define_with_hex_fp_value (const char *macro,
577                                   tree type ATTRIBUTE_UNUSED, int digits,
578                                   const char *hex_str, const char *fp_suffix)
579 {
580   REAL_VALUE_TYPE real;
581   char dec_str[64], buf[256];
582
583   /* Hex values are really cool and convenient, except that they're
584      not supported in strict ISO C90 mode.  First, the "p-" sequence
585      is not valid as part of a preprocessor number.  Second, we get a
586      pedwarn from the preprocessor, which has no context, so we can't
587      suppress the warning with __extension__.
588
589      So instead what we do is construct the number in hex (because
590      it's easy to get the exact correct value), parse it as a real,
591      then print it back out as decimal.  */
592
593   real_from_string (&real, hex_str);
594   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
595
596   sprintf (buf, "%s=%s%s", macro, dec_str, fp_suffix);
597   cpp_define (parse_in, buf);
598 }
599
600 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
601    1 for type "long" and 2 for "long long".  We have to handle
602    unsigned types, since wchar_t might be unsigned.  */
603
604 static void
605 builtin_define_type_max (const char *macro, tree type, int is_long)
606 {
607   static const char *const values[]
608     = { "127", "255",
609         "32767", "65535",
610         "2147483647", "4294967295",
611         "9223372036854775807", "18446744073709551615",
612         "170141183460469231731687303715884105727",
613         "340282366920938463463374607431768211455" };
614   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
615
616   const char *value, *suffix;
617   char *buf;
618   size_t idx;
619
620   /* Pre-rendering the values mean we don't have to futz with printing a
621      multi-word decimal value.  There are also a very limited number of
622      precisions that we support, so it's really a waste of time.  */
623   switch (TYPE_PRECISION (type))
624     {
625     case 8:     idx = 0; break;
626     case 16:    idx = 2; break;
627     case 32:    idx = 4; break;
628     case 64:    idx = 6; break;
629     case 128:   idx = 8; break;
630     default:    gcc_unreachable ();
631     }
632
633   value = values[idx + TYPE_UNSIGNED (type)];
634   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
635
636   buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1);
637   sprintf (buf, "%s=%s%s", macro, value, suffix);
638
639   cpp_define (parse_in, buf);
640 }