OSDN Git Service

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