OSDN Git Service

* include/cpplib.h (struct cpp_callbacks): Add user_builtin_macro
[pf3gnuchains/gcc-fork.git] / gcc / c-family / c-cppbuiltin.c
1 /* Define builtin-in macros for the C family front ends.
2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3    Free Software Foundation, Inc.
4
5 This file is part of GCC.
6
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 3, or (at your option) any later
10 version.
11
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
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
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 "c-common.h"
29 #include "c-pragma.h"
30 #include "output.h"
31 #include "except.h"             /* For USING_SJLJ_EXCEPTIONS.  */
32 #include "debug.h"              /* For dwarf2out_do_cfi_asm.  */
33 #include "toplev.h"
34 #include "tm_p.h"               /* For TARGET_CPU_CPP_BUILTINS & friends.  */
35 #include "target.h"
36 #include "cpp-id-data.h"
37
38 #ifndef TARGET_OS_CPP_BUILTINS
39 # define TARGET_OS_CPP_BUILTINS()
40 #endif
41
42 #ifndef TARGET_OBJFMT_CPP_BUILTINS
43 # define TARGET_OBJFMT_CPP_BUILTINS()
44 #endif
45
46 #ifndef REGISTER_PREFIX
47 #define REGISTER_PREFIX ""
48 #endif
49
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_int_value (const char *, HOST_WIDE_INT);
53 static void builtin_define_with_hex_fp_value (const char *, tree,
54                                               int, const char *,
55                                               const char *,
56                                               const char *);
57 static void builtin_define_stdint_macros (void);
58 static void builtin_define_constants (const char *, tree);
59 static void builtin_define_type_max (const char *, tree);
60 static void builtin_define_type_minmax (const char *, const char *, tree);
61 static void builtin_define_type_precision (const char *, tree);
62 static void builtin_define_type_sizeof (const char *, tree);
63 static void builtin_define_float_constants (const char *,
64                                             const char *,
65                                             const char *,
66                                             tree);
67 static void define__GNUC__ (void);
68
69 /* Define NAME with value TYPE precision.  */
70 static void
71 builtin_define_type_precision (const char *name, tree type)
72 {
73   builtin_define_with_int_value (name, TYPE_PRECISION (type));
74 }
75
76 /* Define NAME with value TYPE size_unit.  */
77 static void
78 builtin_define_type_sizeof (const char *name, tree type)
79 {
80   builtin_define_with_int_value (name,
81                                  tree_low_cst (TYPE_SIZE_UNIT (type), 1));
82 }
83
84 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
85    and FP_CAST. */
86 static void
87 builtin_define_float_constants (const char *name_prefix,
88                                 const char *fp_suffix,
89                                 const char *fp_cast,
90                                 tree type)
91 {
92   /* Used to convert radix-based values to base 10 values in several cases.
93
94      In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
95      least 6 significant digits for correct results.  Using the fraction
96      formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
97      intermediate; perhaps someone can find a better approximation, in the
98      mean time, I suspect using doubles won't harm the bootstrap here.  */
99
100   const double log10_2 = .30102999566398119521;
101   double log10_b;
102   const struct real_format *fmt;
103   const struct real_format *ldfmt;
104
105   char name[64], buf[128];
106   int dig, min_10_exp, max_10_exp;
107   int decimal_dig;
108   int type_decimal_dig;
109
110   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
111   gcc_assert (fmt->b != 10);
112   ldfmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
113   gcc_assert (ldfmt->b != 10);
114
115   /* The radix of the exponent representation.  */
116   if (type == float_type_node)
117     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
118   log10_b = log10_2;
119
120   /* The number of radix digits, p, in the floating-point significand.  */
121   sprintf (name, "__%s_MANT_DIG__", name_prefix);
122   builtin_define_with_int_value (name, fmt->p);
123
124   /* The number of decimal digits, q, such that any floating-point number
125      with q decimal digits can be rounded into a floating-point number with
126      p radix b digits and back again without change to the q decimal digits,
127
128         p log10 b                       if b is a power of 10
129         floor((p - 1) log10 b)          otherwise
130   */
131   dig = (fmt->p - 1) * log10_b;
132   sprintf (name, "__%s_DIG__", name_prefix);
133   builtin_define_with_int_value (name, dig);
134
135   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
136   sprintf (name, "__%s_MIN_EXP__", name_prefix);
137   sprintf (buf, "(%d)", fmt->emin);
138   builtin_define_with_value (name, buf, 0);
139
140   /* The minimum negative int x such that 10**x is a normalized float,
141
142           ceil (log10 (b ** (emin - 1)))
143         = ceil (log10 (b) * (emin - 1))
144
145      Recall that emin is negative, so the integer truncation calculates
146      the ceiling, not the floor, in this case.  */
147   min_10_exp = (fmt->emin - 1) * log10_b;
148   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
149   sprintf (buf, "(%d)", min_10_exp);
150   builtin_define_with_value (name, buf, 0);
151
152   /* The maximum int x such that b**(x-1) is a representable float.  */
153   sprintf (name, "__%s_MAX_EXP__", name_prefix);
154   builtin_define_with_int_value (name, fmt->emax);
155
156   /* The maximum int x such that 10**x is in the range of representable
157      finite floating-point numbers,
158
159           floor (log10((1 - b**-p) * b**emax))
160         = floor (log10(1 - b**-p) + log10(b**emax))
161         = floor (log10(1 - b**-p) + log10(b)*emax)
162
163      The safest thing to do here is to just compute this number.  But since
164      we don't link cc1 with libm, we cannot.  We could implement log10 here
165      a series expansion, but that seems too much effort because:
166
167      Note that the first term, for all extant p, is a number exceedingly close
168      to zero, but slightly negative.  Note that the second term is an integer
169      scaling an irrational number, and that because of the floor we are only
170      interested in its integral portion.
171
172      In order for the first term to have any effect on the integral portion
173      of the second term, the second term has to be exceedingly close to an
174      integer itself (e.g. 123.000000000001 or something).  Getting a result
175      that close to an integer requires that the irrational multiplicand have
176      a long series of zeros in its expansion, which doesn't occur in the
177      first 20 digits or so of log10(b).
178
179      Hand-waving aside, crunching all of the sets of constants above by hand
180      does not yield a case for which the first term is significant, which
181      in the end is all that matters.  */
182   max_10_exp = fmt->emax * log10_b;
183   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
184   builtin_define_with_int_value (name, max_10_exp);
185
186   /* The number of decimal digits, n, such that any floating-point number
187      can be rounded to n decimal digits and back again without change to
188      the value.
189
190         p * log10(b)                    if b is a power of 10
191         ceil(1 + p * log10(b))          otherwise
192
193      The only macro we care about is this number for the widest supported
194      floating type, but we want this value for rendering constants below.  */
195   {
196     double d_decimal_dig
197       = 1 + (fmt->p < ldfmt->p ? ldfmt->p : fmt->p) * log10_b;
198     decimal_dig = d_decimal_dig;
199     if (decimal_dig < d_decimal_dig)
200       decimal_dig++;
201   }
202   /* Similar, for this type rather than long double.  */
203   {
204     double type_d_decimal_dig = 1 + fmt->p * log10_b;
205     type_decimal_dig = type_d_decimal_dig;
206     if (type_decimal_dig < type_d_decimal_dig)
207       type_decimal_dig++;
208   }
209   if (type == long_double_type_node)
210     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
211   else
212     {
213       sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
214       builtin_define_with_int_value (name, type_decimal_dig);
215     }
216
217   /* Since, for the supported formats, B is always a power of 2, we
218      construct the following numbers directly as a hexadecimal
219      constants.  */
220   get_max_float (fmt, buf, sizeof (buf));
221
222   sprintf (name, "__%s_MAX__", name_prefix);
223   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
224
225   /* The minimum normalized positive floating-point number,
226      b**(emin-1).  */
227   sprintf (name, "__%s_MIN__", name_prefix);
228   sprintf (buf, "0x1p%d", fmt->emin - 1);
229   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
230
231   /* The difference between 1 and the least value greater than 1 that is
232      representable in the given floating point type, b**(1-p).  */
233   sprintf (name, "__%s_EPSILON__", name_prefix);
234   if (fmt->pnan < fmt->p)
235     /* This is an IBM extended double format, so 1.0 + any double is
236        representable precisely.  */
237       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
238     else
239       sprintf (buf, "0x1p%d", 1 - fmt->p);
240   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
241
242   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
243      positive floating-point number, b**(emin-p).  Zero for formats that
244      don't support denormals.  */
245   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
246   if (fmt->has_denorm)
247     {
248       sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
249       builtin_define_with_hex_fp_value (name, type, decimal_dig,
250                                         buf, fp_suffix, fp_cast);
251     }
252   else
253     {
254       sprintf (buf, "0.0%s", fp_suffix);
255       builtin_define_with_value (name, buf, 0);
256     }
257
258   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
259   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
260
261   /* For C++ std::numeric_limits<T>::has_infinity.  */
262   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
263   builtin_define_with_int_value (name,
264                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
265   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
266      predicate to distinguish a target that has both quiet and
267      signalling NaNs from a target that has only quiet NaNs or only
268      signalling NaNs, so we assume that a target that has any kind of
269      NaN has quiet NaNs.  */
270   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
271   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
272 }
273
274 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
275 static void
276 builtin_define_decimal_float_constants (const char *name_prefix,
277                                         const char *suffix,
278                                         tree type)
279 {
280   const struct real_format *fmt;
281   char name[64], buf[128], *p;
282   int digits;
283
284   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
285
286   /* The number of radix digits, p, in the significand.  */
287   sprintf (name, "__%s_MANT_DIG__", name_prefix);
288   builtin_define_with_int_value (name, fmt->p);
289
290   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
291   sprintf (name, "__%s_MIN_EXP__", name_prefix);
292   sprintf (buf, "(%d)", fmt->emin);
293   builtin_define_with_value (name, buf, 0);
294
295   /* The maximum int x such that b**(x-1) is a representable float.  */
296   sprintf (name, "__%s_MAX_EXP__", name_prefix);
297   builtin_define_with_int_value (name, fmt->emax);
298
299   /* Compute the minimum representable value.  */
300   sprintf (name, "__%s_MIN__", name_prefix);
301   sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
302   builtin_define_with_value (name, buf, 0);
303
304   /* Compute the maximum representable value.  */
305   sprintf (name, "__%s_MAX__", name_prefix);
306   p = buf;
307   for (digits = fmt->p; digits; digits--)
308     {
309       *p++ = '9';
310       if (digits == fmt->p)
311         *p++ = '.';
312     }
313   *p = 0;
314   /* fmt->p plus 1, to account for the decimal point and fmt->emax
315      minus 1 because the digits are nines, not 1.0.  */
316   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
317   builtin_define_with_value (name, buf, 0);
318
319   /* Compute epsilon (the difference between 1 and least value greater
320      than 1 representable).  */
321   sprintf (name, "__%s_EPSILON__", name_prefix);
322   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
323   builtin_define_with_value (name, buf, 0);
324
325   /* Minimum subnormal positive decimal value.  */
326   sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
327   p = buf;
328   for (digits = fmt->p; digits > 1; digits--)
329     {
330       *p++ = '0';
331       if (digits == fmt->p)
332         *p++ = '.';
333     }
334   *p = 0;
335   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
336   builtin_define_with_value (name, buf, 0);
337 }
338
339 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX.  */
340
341 static void
342 builtin_define_fixed_point_constants (const char *name_prefix,
343                                       const char *suffix,
344                                       tree type)
345 {
346   char name[64], buf[256], *new_buf;
347   int i, mod;
348
349   sprintf (name, "__%s_FBIT__", name_prefix);
350   builtin_define_with_int_value (name, TYPE_FBIT (type));
351
352   sprintf (name, "__%s_IBIT__", name_prefix);
353   builtin_define_with_int_value (name, TYPE_IBIT (type));
354
355   /* If there is no suffix, defines are for fixed-point modes.
356      We just return.  */
357   if (strcmp (suffix, "") == 0)
358     return;
359
360   if (TYPE_UNSIGNED (type))
361     {
362       sprintf (name, "__%s_MIN__", name_prefix);
363       sprintf (buf, "0.0%s", suffix);
364       builtin_define_with_value (name, buf, 0);
365     }
366   else
367     {
368       sprintf (name, "__%s_MIN__", name_prefix);
369       if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
370         sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
371                  TYPE_IBIT (type) - 1, suffix);
372       else
373         sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
374       builtin_define_with_value (name, buf, 0);
375     }
376
377   sprintf (name, "__%s_MAX__", name_prefix);
378   sprintf (buf, "0X");
379   new_buf = buf + 2;
380   mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
381   if (mod)
382     sprintf (new_buf++, "%x", (1 << mod) - 1);
383   for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
384     sprintf (new_buf++, "F");
385   sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
386   builtin_define_with_value (name, buf, 0);
387
388   sprintf (name, "__%s_EPSILON__", name_prefix);
389   sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
390   builtin_define_with_value (name, buf, 0);
391 }
392
393 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
394 static void
395 define__GNUC__ (void)
396 {
397   int major, minor, patchlevel;
398
399   if (sscanf (BASEVER, "%d.%d.%d", &major, &minor, &patchlevel) != 3)
400     {
401       sscanf (BASEVER, "%d.%d", &major, &minor);
402       patchlevel = 0;
403     }
404   cpp_define_formatted (parse_in, "__GNUC__=%d", major);
405   cpp_define_formatted (parse_in, "__GNUC_MINOR__=%d", minor);
406   cpp_define_formatted (parse_in, "__GNUC_PATCHLEVEL__=%d", patchlevel);
407
408   if (c_dialect_cxx ())
409     cpp_define_formatted (parse_in, "__GNUG__=%d", major);
410 }
411
412 /* Define macros used by <stdint.h>.  */
413 static void
414 builtin_define_stdint_macros (void)
415 {
416   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
417   builtin_define_constants ("__INTMAX_C", intmax_type_node);
418   builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
419   builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
420   if (sig_atomic_type_node)
421     builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
422                                 sig_atomic_type_node);
423   if (int8_type_node)
424     builtin_define_type_max ("__INT8_MAX__", int8_type_node);
425   if (int16_type_node)
426     builtin_define_type_max ("__INT16_MAX__", int16_type_node);
427   if (int32_type_node)
428     builtin_define_type_max ("__INT32_MAX__", int32_type_node);
429   if (int64_type_node)
430     builtin_define_type_max ("__INT64_MAX__", int64_type_node);
431   if (uint8_type_node)
432     builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
433   if (uint16_type_node)
434     builtin_define_type_max ("__UINT16_MAX__", uint16_type_node);
435   if (c_uint32_type_node)
436     builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
437   if (c_uint64_type_node)
438     builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
439   if (int_least8_type_node)
440     {
441       builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
442       builtin_define_constants ("__INT8_C", int_least8_type_node);
443     }
444   if (int_least16_type_node)
445     {
446       builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
447       builtin_define_constants ("__INT16_C", int_least16_type_node);
448     }
449   if (int_least32_type_node)
450     {
451       builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
452       builtin_define_constants ("__INT32_C", int_least32_type_node);
453     }
454   if (int_least64_type_node)
455     {
456       builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
457       builtin_define_constants ("__INT64_C", int_least64_type_node);
458     }
459   if (uint_least8_type_node)
460     {
461       builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
462       builtin_define_constants ("__UINT8_C", uint_least8_type_node);
463     }
464   if (uint_least16_type_node)
465     {
466       builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
467       builtin_define_constants ("__UINT16_C", uint_least16_type_node);
468     }
469   if (uint_least32_type_node)
470     {
471       builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
472       builtin_define_constants ("__UINT32_C", uint_least32_type_node);
473     }
474   if (uint_least64_type_node)
475     {
476       builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
477       builtin_define_constants ("__UINT64_C", uint_least64_type_node);
478     }
479   if (int_fast8_type_node)
480     builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
481   if (int_fast16_type_node)
482     builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
483   if (int_fast32_type_node)
484     builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
485   if (int_fast64_type_node)
486     builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
487   if (uint_fast8_type_node)
488     builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
489   if (uint_fast16_type_node)
490     builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
491   if (uint_fast32_type_node)
492     builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
493   if (uint_fast64_type_node)
494     builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
495   if (intptr_type_node)
496     builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
497   if (uintptr_type_node)
498     builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
499 }
500
501 /* Adjust the optimization macros when a #pragma GCC optimization is done to
502    reflect the current level.  */
503 void
504 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
505                                 tree cur_tree)
506 {
507   struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
508   struct cl_optimization *cur  = TREE_OPTIMIZATION (cur_tree);
509   bool prev_fast_math;
510   bool cur_fast_math;
511
512   /* -undef turns off target-specific built-ins.  */
513   if (flag_undef)
514     return;
515
516   /* Other target-independent built-ins determined by command-line
517      options.  */
518   if (!prev->optimize_size && cur->optimize_size)
519     cpp_define (pfile, "__OPTIMIZE_SIZE__");
520   else if (prev->optimize_size && !cur->optimize_size)
521     cpp_undef (pfile, "__OPTIMIZE_SIZE__");
522
523   if (!prev->optimize && cur->optimize)
524     cpp_define (pfile, "__OPTIMIZE__");
525   else if (prev->optimize && !cur->optimize)
526     cpp_undef (pfile, "__OPTIMIZE__");
527
528   prev_fast_math = fast_math_flags_struct_set_p (prev);
529   cur_fast_math  = fast_math_flags_struct_set_p (cur);
530   if (!prev_fast_math && cur_fast_math)
531     cpp_define (pfile, "__FAST_MATH__");
532   else if (prev_fast_math && !cur_fast_math)
533     cpp_undef (pfile, "__FAST_MATH__");
534
535   if (!prev->flag_signaling_nans && cur->flag_signaling_nans)
536     cpp_define (pfile, "__SUPPORT_SNAN__");
537   else if (prev->flag_signaling_nans && !cur->flag_signaling_nans)
538     cpp_undef (pfile, "__SUPPORT_SNAN__");
539
540   if (!prev->flag_finite_math_only && cur->flag_finite_math_only)
541     {
542       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
543       cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
544     }
545   else if (!prev->flag_finite_math_only && cur->flag_finite_math_only)
546     {
547       cpp_undef (pfile, "__FINITE_MATH_ONLY__");
548       cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
549     }
550 }
551
552
553 /* Hook that registers front end and target-specific built-ins.  */
554 void
555 c_cpp_builtins (cpp_reader *pfile)
556 {
557   /* -undef turns off target-specific built-ins.  */
558   if (flag_undef)
559     return;
560
561   define__GNUC__ ();
562
563   /* For stddef.h.  They require macros defined in c-common.c.  */
564   c_stddef_cpp_builtins ();
565
566   if (c_dialect_cxx ())
567     {
568       if (flag_weak && SUPPORTS_ONE_ONLY)
569         cpp_define (pfile, "__GXX_WEAK__=1");
570       else
571         cpp_define (pfile, "__GXX_WEAK__=0");
572       if (warn_deprecated)
573         cpp_define (pfile, "__DEPRECATED");
574       if (flag_rtti)
575         cpp_define (pfile, "__GXX_RTTI");
576       if (cxx_dialect == cxx0x)
577         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
578     }
579   /* Note that we define this for C as well, so that we know if
580      __attribute__((cleanup)) will interface with EH.  */
581   if (flag_exceptions)
582     cpp_define (pfile, "__EXCEPTIONS");
583
584   /* Represents the C++ ABI version, always defined so it can be used while
585      preprocessing C and assembler.  */
586   if (flag_abi_version == 0)
587     /* Use a very large value so that:
588
589          #if __GXX_ABI_VERSION >= <value for version X>
590
591        will work whether the user explicitly says "-fabi-version=x" or
592        "-fabi-version=0".  Do not use INT_MAX because that will be
593        different from system to system.  */
594     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
595   else if (flag_abi_version == 1)
596     /* Due to a historical accident, this version had the value
597        "102".  */
598     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
599   else
600     /* Newer versions have values 1002, 1003, ....  */
601     builtin_define_with_int_value ("__GXX_ABI_VERSION",
602                                    1000 + flag_abi_version);
603
604   /* libgcc needs to know this.  */
605   if (USING_SJLJ_EXCEPTIONS)
606     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
607
608   /* limits.h and stdint.h need to know these.  */
609   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
610   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
611   builtin_define_type_max ("__INT_MAX__", integer_type_node);
612   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
613   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
614   builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
615                               underlying_wchar_type_node);
616   builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
617   builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
618   builtin_define_type_max ("__SIZE_MAX__", size_type_node);
619
620   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
621
622   /* stdint.h and the testsuite need to know these.  */
623   builtin_define_stdint_macros ();
624
625   /* float.h needs to know these.  */
626
627   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
628                                  TARGET_FLT_EVAL_METHOD);
629
630   /* And decfloat.h needs this.  */
631   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
632                                  TARGET_DEC_EVAL_METHOD);
633
634   builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
635   /* Cast the double precision constants.  This is needed when single
636      precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
637      is used.  The correct result is computed by the compiler when using
638      macros that include a cast.  */
639   builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
640   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
641
642   /* For decfloat.h.  */
643   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
644   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
645   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
646
647   /* For fixed-point fibt, ibit, max, min, and epsilon.  */
648   if (targetm.fixed_point_supported_p ())
649     {
650       builtin_define_fixed_point_constants ("SFRACT", "HR",
651                                             short_fract_type_node);
652       builtin_define_fixed_point_constants ("USFRACT", "UHR",
653                                             unsigned_short_fract_type_node);
654       builtin_define_fixed_point_constants ("FRACT", "R",
655                                             fract_type_node);
656       builtin_define_fixed_point_constants ("UFRACT", "UR",
657                                             unsigned_fract_type_node);
658       builtin_define_fixed_point_constants ("LFRACT", "LR",
659                                             long_fract_type_node);
660       builtin_define_fixed_point_constants ("ULFRACT", "ULR",
661                                             unsigned_long_fract_type_node);
662       builtin_define_fixed_point_constants ("LLFRACT", "LLR",
663                                             long_long_fract_type_node);
664       builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
665                                             unsigned_long_long_fract_type_node);
666       builtin_define_fixed_point_constants ("SACCUM", "HK",
667                                             short_accum_type_node);
668       builtin_define_fixed_point_constants ("USACCUM", "UHK",
669                                             unsigned_short_accum_type_node);
670       builtin_define_fixed_point_constants ("ACCUM", "K",
671                                             accum_type_node);
672       builtin_define_fixed_point_constants ("UACCUM", "UK",
673                                             unsigned_accum_type_node);
674       builtin_define_fixed_point_constants ("LACCUM", "LK",
675                                             long_accum_type_node);
676       builtin_define_fixed_point_constants ("ULACCUM", "ULK",
677                                             unsigned_long_accum_type_node);
678       builtin_define_fixed_point_constants ("LLACCUM", "LLK",
679                                             long_long_accum_type_node);
680       builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
681                                             unsigned_long_long_accum_type_node);
682
683       builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
684       builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
685       builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
686       builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
687       builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
688       builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
689       builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
690       builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
691       builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
692       builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
693       builtin_define_fixed_point_constants ("HA", "", ha_type_node);
694       builtin_define_fixed_point_constants ("SA", "", sa_type_node);
695       builtin_define_fixed_point_constants ("DA", "", da_type_node);
696       builtin_define_fixed_point_constants ("TA", "", ta_type_node);
697       builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
698       builtin_define_fixed_point_constants ("USA", "", usa_type_node);
699       builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
700       builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
701     }
702
703   /* For use in assembly language.  */
704   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
705   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
706
707   /* Misc.  */
708   builtin_define_with_value ("__VERSION__", version_string, 1);
709
710   if (flag_gnu89_inline)
711     cpp_define (pfile, "__GNUC_GNU_INLINE__");
712   else
713     cpp_define (pfile, "__GNUC_STDC_INLINE__");
714
715   /* Definitions for LP64 model.  */
716   if (TYPE_PRECISION (long_integer_type_node) == 64
717       && POINTER_SIZE == 64
718       && TYPE_PRECISION (integer_type_node) == 32)
719     {
720       cpp_define (pfile, "_LP64");
721       cpp_define (pfile, "__LP64__");
722     }
723
724   /* Other target-independent built-ins determined by command-line
725      options.  */
726   if (optimize_size)
727     cpp_define (pfile, "__OPTIMIZE_SIZE__");
728   if (optimize)
729     cpp_define (pfile, "__OPTIMIZE__");
730
731   if (fast_math_flags_set_p ())
732     cpp_define (pfile, "__FAST_MATH__");
733   if (flag_no_inline)
734     cpp_define (pfile, "__NO_INLINE__");
735   if (flag_signaling_nans)
736     cpp_define (pfile, "__SUPPORT_SNAN__");
737   if (flag_finite_math_only)
738     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
739   else
740     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
741   if (flag_pic)
742     {
743       builtin_define_with_int_value ("__pic__", flag_pic);
744       builtin_define_with_int_value ("__PIC__", flag_pic);
745     }
746   if (flag_pie)
747     {
748       builtin_define_with_int_value ("__pie__", flag_pie);
749       builtin_define_with_int_value ("__PIE__", flag_pie);
750     }
751
752   if (flag_iso)
753     cpp_define (pfile, "__STRICT_ANSI__");
754
755   if (!flag_signed_char)
756     cpp_define (pfile, "__CHAR_UNSIGNED__");
757
758   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
759     cpp_define (pfile, "__WCHAR_UNSIGNED__");
760
761   /* Tell source code if the compiler makes sync_compare_and_swap
762      builtins available.  */
763 #ifdef HAVE_sync_compare_and_swapqi
764   if (HAVE_sync_compare_and_swapqi)
765     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
766 #endif
767
768 #ifdef HAVE_sync_compare_and_swaphi
769   if (HAVE_sync_compare_and_swaphi)
770     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
771 #endif
772
773 #ifdef HAVE_sync_compare_and_swapsi
774   if (HAVE_sync_compare_and_swapsi)
775     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
776 #endif
777
778 #ifdef HAVE_sync_compare_and_swapdi
779   if (HAVE_sync_compare_and_swapdi)
780     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
781 #endif
782
783 #ifdef HAVE_sync_compare_and_swapti
784   if (HAVE_sync_compare_and_swapti)
785     cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
786 #endif
787
788 #ifdef DWARF2_UNWIND_INFO
789   if (dwarf2out_do_cfi_asm ())
790     cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
791 #endif
792
793   /* Make the choice of ObjC runtime visible to source code.  */
794   if (c_dialect_objc () && flag_next_runtime)
795     cpp_define (pfile, "__NEXT_RUNTIME__");
796
797   /* Show the availability of some target pragmas.  */
798   cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
799
800   if (targetm.handle_pragma_extern_prefix)
801     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
802
803   /* Make the choice of the stack protector runtime visible to source code.
804      The macro names and values here were chosen for compatibility with an
805      earlier implementation, i.e. ProPolice.  */
806   if (flag_stack_protect == 2)
807     cpp_define (pfile, "__SSP_ALL__=2");
808   else if (flag_stack_protect == 1)
809     cpp_define (pfile, "__SSP__=1");
810
811   if (flag_openmp)
812     cpp_define (pfile, "_OPENMP=200805");
813
814   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
815   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
816   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
817                               long_long_integer_type_node);
818   if (int128_integer_type_node != NULL_TREE)
819     builtin_define_type_sizeof ("__SIZEOF_INT128__",
820                                 int128_integer_type_node);
821   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
822   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
823   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
824   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
825   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
826   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
827   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
828   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
829                               unsigned_ptrdiff_type_node);
830   /* ptr_type_node can't be used here since ptr_mode is only set when
831      toplev calls backend_init which is not done with -E switch.  */
832   builtin_define_with_int_value ("__SIZEOF_POINTER__",
833                                  POINTER_SIZE / BITS_PER_UNIT);
834
835   /* A straightforward target hook doesn't work, because of problems
836      linking that hook's body when part of non-C front ends.  */
837 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
838 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
839 # define builtin_define(TXT) cpp_define (pfile, TXT)
840 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
841   TARGET_CPU_CPP_BUILTINS ();
842   TARGET_OS_CPP_BUILTINS ();
843   TARGET_OBJFMT_CPP_BUILTINS ();
844
845   /* Support the __declspec keyword by turning them into attributes.
846      Note that the current way we do this may result in a collision
847      with predefined attributes later on.  This can be solved by using
848      one attribute, say __declspec__, and passing args to it.  The
849      problem with that approach is that args are not accumulated: each
850      new appearance would clobber any existing args.  */
851   if (TARGET_DECLSPEC)
852     builtin_define ("__declspec(x)=__attribute__((x))");
853
854   /* If decimal floating point is supported, tell the user if the
855      alternate format (BID) is used instead of the standard (DPD)
856      format.  */
857   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
858     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
859
860   builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__",
861                                  BIGGEST_ALIGNMENT / BITS_PER_UNIT);
862 }
863
864 /* Pass an object-like macro.  If it doesn't lie in the user's
865    namespace, defines it unconditionally.  Otherwise define a version
866    with two leading underscores, and another version with two leading
867    and trailing underscores, and define the original only if an ISO
868    standard was not nominated.
869
870    e.g. passing "unix" defines "__unix", "__unix__" and possibly
871    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
872    "_mips".  */
873 void
874 builtin_define_std (const char *macro)
875 {
876   size_t len = strlen (macro);
877   char *buff = (char *) alloca (len + 5);
878   char *p = buff + 2;
879   char *q = p + len;
880
881   /* prepend __ (or maybe just _) if in user's namespace.  */
882   memcpy (p, macro, len + 1);
883   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
884     {
885       if (*p != '_')
886         *--p = '_';
887       if (p[1] != '_')
888         *--p = '_';
889     }
890   cpp_define (parse_in, p);
891
892   /* If it was in user's namespace...  */
893   if (p != buff + 2)
894     {
895       /* Define the macro with leading and following __.  */
896       if (q[-1] != '_')
897         *q++ = '_';
898       if (q[-2] != '_')
899         *q++ = '_';
900       *q = '\0';
901       cpp_define (parse_in, p);
902
903       /* Finally, define the original macro if permitted.  */
904       if (!flag_iso)
905         cpp_define (parse_in, macro);
906     }
907 }
908
909 /* Pass an object-like macro and a value to define it to.  The third
910    parameter says whether or not to turn the value into a string
911    constant.  */
912 void
913 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
914 {
915   char *buf;
916   size_t mlen = strlen (macro);
917   size_t elen = strlen (expansion);
918   size_t extra = 2;  /* space for an = and a NUL */
919
920   if (is_str)
921     extra += 2;  /* space for two quote marks */
922
923   buf = (char *) alloca (mlen + elen + extra);
924   if (is_str)
925     sprintf (buf, "%s=\"%s\"", macro, expansion);
926   else
927     sprintf (buf, "%s=%s", macro, expansion);
928
929   cpp_define (parse_in, buf);
930 }
931
932
933 /* Pass an object-like macro and an integer value to define it to.  */
934 static void
935 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
936 {
937   char *buf;
938   size_t mlen = strlen (macro);
939   size_t vlen = 18;
940   size_t extra = 2; /* space for = and NUL.  */
941
942   buf = (char *) alloca (mlen + vlen + extra);
943   memcpy (buf, macro, mlen);
944   buf[mlen] = '=';
945   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
946
947   cpp_define (parse_in, buf);
948 }
949
950 /* builtin_define_with_hex_fp_value is very expensive, so the following
951    array and function allows it to be done lazily when __DBL_MAX__
952    etc. is first used.  */
953
954 static struct
955 {
956   const char *hex_str;
957   cpp_macro *macro;
958   enum machine_mode mode;
959   int digits;
960   const char *fp_suffix;
961 } lazy_hex_fp_values[12];
962 static int lazy_hex_fp_value_count;
963
964 static bool
965 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
966                    cpp_hashnode *node)
967 {
968   REAL_VALUE_TYPE real;
969   char dec_str[64], buf1[256];
970   unsigned int idx;
971   if (node->value.builtin < BT_FIRST_USER
972       || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
973     return false;
974
975   idx = node->value.builtin - BT_FIRST_USER;
976   real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
977   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
978                             lazy_hex_fp_values[idx].digits, 0,
979                             lazy_hex_fp_values[idx].mode);
980
981   sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
982   node->flags &= ~(NODE_BUILTIN | NODE_USED);
983   node->value.macro = lazy_hex_fp_values[idx].macro;
984   for (idx = 0; idx < node->value.macro->count; idx++)
985     if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
986       break;
987   gcc_assert (idx < node->value.macro->count);
988   node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
989   node->value.macro->exp.tokens[idx].val.str.text
990     = (const unsigned char *) xstrdup (buf1);
991   return true;
992 }
993
994 /* Pass an object-like macro a hexadecimal floating-point value.  */
995 static void
996 builtin_define_with_hex_fp_value (const char *macro,
997                                   tree type, int digits,
998                                   const char *hex_str,
999                                   const char *fp_suffix,
1000                                   const char *fp_cast)
1001 {
1002   REAL_VALUE_TYPE real;
1003   char dec_str[64], buf1[256], buf2[256];
1004
1005   /* This is very expensive, so if possible expand them lazily.  */
1006   if (lazy_hex_fp_value_count < 12
1007       && flag_dump_macros == 0
1008       && !cpp_get_options (parse_in)->traditional)
1009     {
1010       struct cpp_hashnode *node;
1011       if (lazy_hex_fp_value_count == 0)
1012         cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1013       sprintf (buf2, fp_cast, "1.1");
1014       sprintf (buf1, "%s=%s", macro, buf2);
1015       cpp_define (parse_in, buf1);
1016       node = C_CPP_HASHNODE (get_identifier (macro));
1017       lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str = xstrdup (hex_str);
1018       lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1019       lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1020       lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1021       lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1022       node->flags |= NODE_BUILTIN;
1023       node->value.builtin = BT_FIRST_USER + lazy_hex_fp_value_count;
1024       lazy_hex_fp_value_count++;
1025       return;
1026     }
1027
1028   /* Hex values are really cool and convenient, except that they're
1029      not supported in strict ISO C90 mode.  First, the "p-" sequence
1030      is not valid as part of a preprocessor number.  Second, we get a
1031      pedwarn from the preprocessor, which has no context, so we can't
1032      suppress the warning with __extension__.
1033
1034      So instead what we do is construct the number in hex (because
1035      it's easy to get the exact correct value), parse it as a real,
1036      then print it back out as decimal.  */
1037
1038   real_from_string (&real, hex_str);
1039   real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1040                             TYPE_MODE (type));
1041
1042   /* Assemble the macro in the following fashion
1043      macro = fp_cast [dec_str fp_suffix] */
1044   sprintf (buf1, "%s%s", dec_str, fp_suffix);
1045   sprintf (buf2, fp_cast, buf1);
1046   sprintf (buf1, "%s=%s", macro, buf2);
1047
1048   cpp_define (parse_in, buf1);
1049 }
1050
1051 /* Return a string constant for the suffix for a value of type TYPE
1052    promoted according to the integer promotions.  The type must be one
1053    of the standard integer type nodes.  */
1054
1055 static const char *
1056 type_suffix (tree type)
1057 {
1058   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1059   int unsigned_suffix;
1060   int is_long;
1061
1062   if (type == long_long_integer_type_node
1063       || type == long_long_unsigned_type_node)
1064     is_long = 2;
1065   else if (type == long_integer_type_node
1066            || type == long_unsigned_type_node)
1067     is_long = 1;
1068   else if (type == integer_type_node
1069            || type == unsigned_type_node
1070            || type == short_integer_type_node
1071            || type == short_unsigned_type_node
1072            || type == signed_char_type_node
1073            || type == unsigned_char_type_node
1074            /* ??? "char" is not a signed or unsigned integer type and
1075               so is not permitted for the standard typedefs, but some
1076               systems use it anyway.  */
1077            || type == char_type_node)
1078     is_long = 0;
1079   else
1080     gcc_unreachable ();
1081
1082   unsigned_suffix = TYPE_UNSIGNED (type);
1083   if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1084     unsigned_suffix = 0;
1085   return suffixes[is_long * 2 + unsigned_suffix];
1086 }
1087
1088 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE.  */
1089 static void
1090 builtin_define_constants (const char *macro, tree type)
1091 {
1092   const char *suffix;
1093   char *buf;
1094
1095   suffix = type_suffix (type);
1096
1097   if (suffix[0] == 0)
1098     {
1099       buf = (char *) alloca (strlen (macro) + 6);
1100       sprintf (buf, "%s(c)=c", macro);
1101     }
1102   else
1103     {
1104       buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1105       sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1106     }
1107
1108   cpp_define (parse_in, buf);
1109 }
1110
1111 /* Define MAX for TYPE based on the precision of the type.  */
1112
1113 static void
1114 builtin_define_type_max (const char *macro, tree type)
1115 {
1116   builtin_define_type_minmax (NULL, macro, type);
1117 }
1118
1119 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1120    precision of the type.  */
1121
1122 static void
1123 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1124                             tree type)
1125 {
1126   static const char *const values[]
1127     = { "127", "255",
1128         "32767", "65535",
1129         "2147483647", "4294967295",
1130         "9223372036854775807", "18446744073709551615",
1131         "170141183460469231731687303715884105727",
1132         "340282366920938463463374607431768211455" };
1133
1134   const char *value, *suffix;
1135   char *buf;
1136   size_t idx;
1137
1138   /* Pre-rendering the values mean we don't have to futz with printing a
1139      multi-word decimal value.  There are also a very limited number of
1140      precisions that we support, so it's really a waste of time.  */
1141   switch (TYPE_PRECISION (type))
1142     {
1143     case 8:     idx = 0; break;
1144     case 16:    idx = 2; break;
1145     case 32:    idx = 4; break;
1146     case 64:    idx = 6; break;
1147     case 128:   idx = 8; break;
1148     default:    gcc_unreachable ();
1149     }
1150
1151   value = values[idx + TYPE_UNSIGNED (type)];
1152   suffix = type_suffix (type);
1153
1154   buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1155                          + strlen (suffix) + 1);
1156   sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1157
1158   cpp_define (parse_in, buf);
1159
1160   if (min_macro)
1161     {
1162       if (TYPE_UNSIGNED (type))
1163         {
1164           buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1165           sprintf (buf, "%s=0%s", min_macro, suffix);
1166         }
1167       else
1168         {
1169           buf = (char *) alloca (strlen (min_macro) + 3
1170                                  + strlen (max_macro) + 6);
1171           sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1172         }
1173       cpp_define (parse_in, buf);
1174     }
1175 }