OSDN Git Service

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