OSDN Git Service

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