OSDN Git Service

* c-cppbuiltin.c (c_cpp_builtins): Remove definition of
[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
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 2, 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 COPYING.  If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "version.h"
28 #include "flags.h"
29 #include "real.h"
30 #include "c-common.h"
31 #include "c-pragma.h"
32 #include "output.h"
33 #include "except.h"             /* For USING_SJLJ_EXCEPTIONS.  */
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_value_n (const char *, const char *,
53                                          size_t);
54 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
55 static void builtin_define_with_hex_fp_value (const char *, tree,
56                                               int, const char *,
57                                               const char *,
58                                               const char *);
59 static void builtin_define_stdint_macros (void);
60 static void builtin_define_type_max (const char *, tree, int);
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
104   char name[64], buf[128];
105   int dig, min_10_exp, max_10_exp;
106   int decimal_dig;
107
108   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
109   gcc_assert (fmt->b != 10);
110
111   /* The radix of the exponent representation.  */
112   if (type == float_type_node)
113     builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
114   log10_b = log10_2 * fmt->log2_b;
115
116   /* The number of radix digits, p, in the floating-point significand.  */
117   sprintf (name, "__%s_MANT_DIG__", name_prefix);
118   builtin_define_with_int_value (name, fmt->p);
119
120   /* The number of decimal digits, q, such that any floating-point number
121      with q decimal digits can be rounded into a floating-point number with
122      p radix b digits and back again without change to the q decimal digits,
123
124         p log10 b                       if b is a power of 10
125         floor((p - 1) log10 b)          otherwise
126   */
127   dig = (fmt->p - 1) * log10_b;
128   sprintf (name, "__%s_DIG__", name_prefix);
129   builtin_define_with_int_value (name, dig);
130
131   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
132   sprintf (name, "__%s_MIN_EXP__", name_prefix);
133   sprintf (buf, "(%d)", fmt->emin);
134   builtin_define_with_value (name, buf, 0);
135
136   /* The minimum negative int x such that 10**x is a normalized float,
137
138           ceil (log10 (b ** (emin - 1)))
139         = ceil (log10 (b) * (emin - 1))
140
141      Recall that emin is negative, so the integer truncation calculates
142      the ceiling, not the floor, in this case.  */
143   min_10_exp = (fmt->emin - 1) * log10_b;
144   sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
145   sprintf (buf, "(%d)", min_10_exp);
146   builtin_define_with_value (name, buf, 0);
147
148   /* The maximum int x such that b**(x-1) is a representable float.  */
149   sprintf (name, "__%s_MAX_EXP__", name_prefix);
150   builtin_define_with_int_value (name, fmt->emax);
151
152   /* The maximum int x such that 10**x is in the range of representable
153      finite floating-point numbers,
154
155           floor (log10((1 - b**-p) * b**emax))
156         = floor (log10(1 - b**-p) + log10(b**emax))
157         = floor (log10(1 - b**-p) + log10(b)*emax)
158
159      The safest thing to do here is to just compute this number.  But since
160      we don't link cc1 with libm, we cannot.  We could implement log10 here
161      a series expansion, but that seems too much effort because:
162
163      Note that the first term, for all extant p, is a number exceedingly close
164      to zero, but slightly negative.  Note that the second term is an integer
165      scaling an irrational number, and that because of the floor we are only
166      interested in its integral portion.
167
168      In order for the first term to have any effect on the integral portion
169      of the second term, the second term has to be exceedingly close to an
170      integer itself (e.g. 123.000000000001 or something).  Getting a result
171      that close to an integer requires that the irrational multiplicand have
172      a long series of zeros in its expansion, which doesn't occur in the
173      first 20 digits or so of log10(b).
174
175      Hand-waving aside, crunching all of the sets of constants above by hand
176      does not yield a case for which the first term is significant, which
177      in the end is all that matters.  */
178   max_10_exp = fmt->emax * log10_b;
179   sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
180   builtin_define_with_int_value (name, max_10_exp);
181
182   /* The number of decimal digits, n, such that any floating-point number
183      can be rounded to n decimal digits and back again without change to
184      the value.
185
186         p * log10(b)                    if b is a power of 10
187         ceil(1 + p * log10(b))          otherwise
188
189      The only macro we care about is this number for the widest supported
190      floating type, but we want this value for rendering constants below.  */
191   {
192     double d_decimal_dig = 1 + fmt->p * log10_b;
193     decimal_dig = d_decimal_dig;
194     if (decimal_dig < d_decimal_dig)
195       decimal_dig++;
196   }
197   if (type == long_double_type_node)
198     builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
199
200   /* Since, for the supported formats, B is always a power of 2, we
201      construct the following numbers directly as a hexadecimal
202      constants.  */
203
204   /* The maximum representable finite floating-point number,
205      (1 - b**-p) * b**emax  */
206   {
207     int i, n;
208     char *p;
209
210     strcpy (buf, "0x0.");
211     n = fmt->p * fmt->log2_b;
212     for (i = 0, p = buf + 4; i + 3 < n; i += 4)
213       *p++ = 'f';
214     if (i < n)
215       *p++ = "08ce"[n - i];
216     sprintf (p, "p%d", fmt->emax * fmt->log2_b);
217     if (fmt->pnan < fmt->p)
218       {
219         /* This is an IBM extended double format made up of two IEEE
220            doubles.  The value of the long double is the sum of the
221            values of the two parts.  The most significant part is
222            required to be the value of the long double rounded to the
223            nearest double.  Rounding means we need a slightly smaller
224            value for LDBL_MAX.  */
225         buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
226       }
227   }
228   sprintf (name, "__%s_MAX__", name_prefix);
229   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
230
231   /* The minimum normalized positive floating-point number,
232      b**(emin-1).  */
233   sprintf (name, "__%s_MIN__", name_prefix);
234   sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
235   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
236
237   /* The difference between 1 and the least value greater than 1 that is
238      representable in the given floating point type, b**(1-p).  */
239   sprintf (name, "__%s_EPSILON__", name_prefix);
240   if (fmt->pnan < fmt->p)
241     /* This is an IBM extended double format, so 1.0 + any double is
242        representable precisely.  */
243       sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
244     else
245       sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
246   builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
247
248   /* For C++ std::numeric_limits<T>::denorm_min.  The minimum denormalized
249      positive floating-point number, b**(emin-p).  Zero for formats that
250      don't support denormals.  */
251   sprintf (name, "__%s_DENORM_MIN__", name_prefix);
252   if (fmt->has_denorm)
253     {
254       sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
255       builtin_define_with_hex_fp_value (name, type, decimal_dig,
256                                         buf, fp_suffix, fp_cast);
257     }
258   else
259     {
260       sprintf (buf, "0.0%s", fp_suffix);
261       builtin_define_with_value (name, buf, 0);
262     }
263
264   sprintf (name, "__%s_HAS_DENORM__", name_prefix);
265   builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
266
267   /* For C++ std::numeric_limits<T>::has_infinity.  */
268   sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
269   builtin_define_with_int_value (name,
270                                  MODE_HAS_INFINITIES (TYPE_MODE (type)));
271   /* For C++ std::numeric_limits<T>::has_quiet_NaN.  We do not have a
272      predicate to distinguish a target that has both quiet and
273      signalling NaNs from a target that has only quiet NaNs or only
274      signalling NaNs, so we assume that a target that has any kind of
275      NaN has quiet NaNs.  */
276   sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
277   builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
278 }
279
280 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
281 static void
282 builtin_define_decimal_float_constants (const char *name_prefix, 
283                                         const char *suffix, 
284                                         tree type)
285 {
286   const struct real_format *fmt;
287   char name[64], buf[128], *p;
288   int digits;
289
290   fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
291
292   /* The number of radix digits, p, in the significand.  */
293   sprintf (name, "__%s_MANT_DIG__", name_prefix);
294   builtin_define_with_int_value (name, fmt->p);
295
296   /* The minimum negative int x such that b**(x-1) is a normalized float.  */
297   sprintf (name, "__%s_MIN_EXP__", name_prefix);
298   sprintf (buf, "(%d)", fmt->emin);
299   builtin_define_with_value (name, buf, 0);
300
301   /* The maximum int x such that b**(x-1) is a representable float.  */
302   sprintf (name, "__%s_MAX_EXP__", name_prefix);
303   builtin_define_with_int_value (name, fmt->emax);
304
305   /* Compute the minimum representable value.  */
306   sprintf (name, "__%s_MIN__", name_prefix);
307   sprintf (buf, "1E%d%s", fmt->emin, suffix);
308   builtin_define_with_value (name, buf, 0); 
309
310   /* Compute the maximum representable value.  */
311   sprintf (name, "__%s_MAX__", name_prefix);
312   p = buf;
313   for (digits = fmt->p; digits; digits--)
314     {
315       *p++ = '9';
316       if (digits == fmt->p)
317         *p++ = '.';
318     }
319   *p = 0;
320   /* fmt->p plus 1, to account for the decimal point.  */
321   sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix); 
322   builtin_define_with_value (name, buf, 0);
323
324   /* Compute epsilon (the difference between 1 and least value greater
325      than 1 representable).  */
326   sprintf (name, "__%s_EPSILON__", name_prefix);
327   sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
328   builtin_define_with_value (name, buf, 0);
329
330   /* Minimum denormalized postive decimal value.  */
331   sprintf (name, "__%s_DEN__", name_prefix);
332   p = buf;
333   for (digits = fmt->p; digits > 1; digits--)
334     {
335       *p++ = '0';
336       if (digits == fmt->p)
337         *p++ = '.';
338     }
339   *p = 0;
340   sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix); 
341   builtin_define_with_value (name, buf, 0);
342 }
343
344 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__.  */
345 static void
346 define__GNUC__ (void)
347 {
348   /* The format of the version string, enforced below, is
349      ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)?  */
350   const char *q, *v = version_string;
351
352   while (*v && !ISDIGIT (*v))
353     v++;
354   gcc_assert (*v && (v <= version_string || v[-1] == '-'));
355
356   q = v;
357   while (ISDIGIT (*v))
358     v++;
359   builtin_define_with_value_n ("__GNUC__", q, v - q);
360   if (c_dialect_cxx ())
361     builtin_define_with_value_n ("__GNUG__", q, v - q);
362
363   gcc_assert (*v == '.' && ISDIGIT (v[1]));
364
365   q = ++v;
366   while (ISDIGIT (*v))
367     v++;
368   builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
369
370   if (*v == '.')
371     {
372       gcc_assert (ISDIGIT (v[1]));
373       q = ++v;
374       while (ISDIGIT (*v))
375         v++;
376       builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
377     }
378   else
379     builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
380
381   gcc_assert (!*v || *v == ' ' || *v == '-');
382 }
383
384 /* Define macros used by <stdint.h>.  Currently only defines limits
385    for intmax_t, used by the testsuite.  */
386 static void
387 builtin_define_stdint_macros (void)
388 {
389   int intmax_long;
390   if (intmax_type_node == long_long_integer_type_node)
391     intmax_long = 2;
392   else if (intmax_type_node == long_integer_type_node)
393     intmax_long = 1;
394   else if (intmax_type_node == integer_type_node)
395     intmax_long = 0;
396   else
397     gcc_unreachable ();
398   builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
399 }
400
401 /* Hook that registers front end and target-specific built-ins.  */
402 void
403 c_cpp_builtins (cpp_reader *pfile)
404 {
405   /* -undef turns off target-specific built-ins.  */
406   if (flag_undef)
407     return;
408
409   define__GNUC__ ();
410
411   /* For stddef.h.  They require macros defined in c-common.c.  */
412   c_stddef_cpp_builtins ();
413
414   if (c_dialect_cxx ())
415     {
416       if (flag_weak && SUPPORTS_ONE_ONLY)
417         cpp_define (pfile, "__GXX_WEAK__=1");
418       else
419         cpp_define (pfile, "__GXX_WEAK__=0");
420       if (warn_deprecated)
421         cpp_define (pfile, "__DEPRECATED");
422       if (flag_cpp0x)
423         cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
424     }
425   /* Note that we define this for C as well, so that we know if
426      __attribute__((cleanup)) will interface with EH.  */
427   if (flag_exceptions)
428     cpp_define (pfile, "__EXCEPTIONS");
429
430   /* Represents the C++ ABI version, always defined so it can be used while
431      preprocessing C and assembler.  */
432   if (flag_abi_version == 0)
433     /* Use a very large value so that:
434
435          #if __GXX_ABI_VERSION >= <value for version X>
436
437        will work whether the user explicitly says "-fabi-version=x" or
438        "-fabi-version=0".  Do not use INT_MAX because that will be
439        different from system to system.  */
440     builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
441   else if (flag_abi_version == 1)
442     /* Due to a historical accident, this version had the value
443        "102".  */
444     builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
445   else
446     /* Newer versions have values 1002, 1003, ....  */
447     builtin_define_with_int_value ("__GXX_ABI_VERSION",
448                                    1000 + flag_abi_version);
449
450   /* libgcc needs to know this.  */
451   if (USING_SJLJ_EXCEPTIONS)
452     cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
453
454   /* limits.h needs to know these.  */
455   builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
456   builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
457   builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
458   builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
459   builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
460   builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
461
462   builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
463
464   /* stdint.h (eventually) and the testsuite need to know these.  */
465   builtin_define_stdint_macros ();
466
467   /* float.h needs to know these.  */
468
469   builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
470                                  TARGET_FLT_EVAL_METHOD);
471
472   /* And decfloat.h needs this.  */
473   builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
474                                  TARGET_DEC_EVAL_METHOD);
475
476   builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
477   /* Cast the double precision constants when single precision constants are
478      specified. The correct result is computed by the compiler when using 
479      macros that include a cast. This has the side-effect of making the value 
480      unusable in const expressions. */
481   if (flag_single_precision_constant)
482     builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
483   else
484     builtin_define_float_constants ("DBL", "", "%s", double_type_node);
485   builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
486
487   /* For decfloat.h.  */
488   builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
489   builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
490   builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
491
492   /* For use in assembly language.  */
493   builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
494   builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
495
496   /* Misc.  */
497   builtin_define_with_value ("__VERSION__", version_string, 1);
498
499   if (flag_gnu89_inline)
500     cpp_define (pfile, "__GNUC_GNU_INLINE__");
501   else
502     cpp_define (pfile, "__GNUC_STDC_INLINE__");
503
504   /* Definitions for LP64 model.  */
505   if (TYPE_PRECISION (long_integer_type_node) == 64
506       && POINTER_SIZE == 64
507       && TYPE_PRECISION (integer_type_node) == 32)
508     {
509       cpp_define (pfile, "_LP64");
510       cpp_define (pfile, "__LP64__");
511     }
512
513   /* Other target-independent built-ins determined by command-line
514      options.  */
515   if (optimize_size)
516     cpp_define (pfile, "__OPTIMIZE_SIZE__");
517   if (optimize)
518     cpp_define (pfile, "__OPTIMIZE__");
519
520   if (fast_math_flags_set_p ())
521     cpp_define (pfile, "__FAST_MATH__");
522   if (flag_really_no_inline)
523     cpp_define (pfile, "__NO_INLINE__");
524   if (flag_signaling_nans)
525     cpp_define (pfile, "__SUPPORT_SNAN__");
526   if (flag_finite_math_only)
527     cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
528   else
529     cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
530   if (flag_pic)
531     {
532       builtin_define_with_int_value ("__pic__", flag_pic);
533       builtin_define_with_int_value ("__PIC__", flag_pic);
534     }
535   if (flag_pie)
536     {
537       builtin_define_with_int_value ("__pie__", flag_pie);
538       builtin_define_with_int_value ("__PIE__", flag_pie);
539     }
540
541   if (flag_iso)
542     cpp_define (pfile, "__STRICT_ANSI__");
543
544   if (!flag_signed_char)
545     cpp_define (pfile, "__CHAR_UNSIGNED__");
546
547   if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
548     cpp_define (pfile, "__WCHAR_UNSIGNED__");
549
550   /* Make the choice of ObjC runtime visible to source code.  */
551   if (c_dialect_objc () && flag_next_runtime)
552     cpp_define (pfile, "__NEXT_RUNTIME__");
553
554   /* Show the availability of some target pragmas.  */
555   if (flag_mudflap || targetm.handle_pragma_redefine_extname)
556     cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
557
558   if (targetm.handle_pragma_extern_prefix)
559     cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
560
561   /* Make the choice of the stack protector runtime visible to source code.
562      The macro names and values here were chosen for compatibility with an
563      earlier implementation, i.e. ProPolice.  */
564   if (flag_stack_protect == 2)
565     cpp_define (pfile, "__SSP_ALL__=2");
566   else if (flag_stack_protect == 1)
567     cpp_define (pfile, "__SSP__=1");
568
569   if (flag_openmp)
570     cpp_define (pfile, "_OPENMP=200505");
571
572   builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
573   builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
574   builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
575                               long_long_integer_type_node);
576   builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
577   builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
578   builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
579   builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
580   builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
581   builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
582   builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
583   builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
584                               unsigned_ptrdiff_type_node);
585   /* ptr_type_node can't be used here since ptr_mode is only set when
586      toplev calls backend_init which is not done with -E switch.  */
587   builtin_define_with_int_value ("__SIZEOF_POINTER__",
588                                  POINTER_SIZE / BITS_PER_UNIT);
589
590   /* A straightforward target hook doesn't work, because of problems
591      linking that hook's body when part of non-C front ends.  */
592 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
593 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
594 # define builtin_define(TXT) cpp_define (pfile, TXT)
595 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
596   TARGET_CPU_CPP_BUILTINS ();
597   TARGET_OS_CPP_BUILTINS ();
598   TARGET_OBJFMT_CPP_BUILTINS ();
599
600   /* Support the __declspec keyword by turning them into attributes.
601      Note that the current way we do this may result in a collision
602      with predefined attributes later on.  This can be solved by using
603      one attribute, say __declspec__, and passing args to it.  The
604      problem with that approach is that args are not accumulated: each
605      new appearance would clobber any existing args.  */
606   if (TARGET_DECLSPEC)
607     builtin_define ("__declspec(x)=__attribute__((x))");
608
609   /* If decimal floating point is supported, tell the user if the
610      alternate format (BID) is used instead of the standard (DPD)
611      format.  */
612   if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
613     cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
614 }
615
616 /* Pass an object-like macro.  If it doesn't lie in the user's
617    namespace, defines it unconditionally.  Otherwise define a version
618    with two leading underscores, and another version with two leading
619    and trailing underscores, and define the original only if an ISO
620    standard was not nominated.
621
622    e.g. passing "unix" defines "__unix", "__unix__" and possibly
623    "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
624    "_mips".  */
625 void
626 builtin_define_std (const char *macro)
627 {
628   size_t len = strlen (macro);
629   char *buff = (char *) alloca (len + 5);
630   char *p = buff + 2;
631   char *q = p + len;
632
633   /* prepend __ (or maybe just _) if in user's namespace.  */
634   memcpy (p, macro, len + 1);
635   if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
636     {
637       if (*p != '_')
638         *--p = '_';
639       if (p[1] != '_')
640         *--p = '_';
641     }
642   cpp_define (parse_in, p);
643
644   /* If it was in user's namespace...  */
645   if (p != buff + 2)
646     {
647       /* Define the macro with leading and following __.  */
648       if (q[-1] != '_')
649         *q++ = '_';
650       if (q[-2] != '_')
651         *q++ = '_';
652       *q = '\0';
653       cpp_define (parse_in, p);
654
655       /* Finally, define the original macro if permitted.  */
656       if (!flag_iso)
657         cpp_define (parse_in, macro);
658     }
659 }
660
661 /* Pass an object-like macro and a value to define it to.  The third
662    parameter says whether or not to turn the value into a string
663    constant.  */
664 void
665 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
666 {
667   char *buf;
668   size_t mlen = strlen (macro);
669   size_t elen = strlen (expansion);
670   size_t extra = 2;  /* space for an = and a NUL */
671
672   if (is_str)
673     extra += 2;  /* space for two quote marks */
674
675   buf = (char *) alloca (mlen + elen + extra);
676   if (is_str)
677     sprintf (buf, "%s=\"%s\"", macro, expansion);
678   else
679     sprintf (buf, "%s=%s", macro, expansion);
680
681   cpp_define (parse_in, buf);
682 }
683
684 /* Pass an object-like macro and a value to define it to.  The third
685    parameter is the length of the expansion.  */
686 static void
687 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
688 {
689   char *buf;
690   size_t mlen = strlen (macro);
691
692   /* Space for an = and a NUL.  */
693   buf = (char *) alloca (mlen + elen + 2);
694   memcpy (buf, macro, mlen);
695   buf[mlen] = '=';
696   memcpy (buf + mlen + 1, expansion, elen);
697   buf[mlen + elen + 1] = '\0';
698
699   cpp_define (parse_in, buf);
700 }
701
702 /* Pass an object-like macro and an integer value to define it to.  */
703 static void
704 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
705 {
706   char *buf;
707   size_t mlen = strlen (macro);
708   size_t vlen = 18;
709   size_t extra = 2; /* space for = and NUL.  */
710
711   buf = (char *) alloca (mlen + vlen + extra);
712   memcpy (buf, macro, mlen);
713   buf[mlen] = '=';
714   sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
715
716   cpp_define (parse_in, buf);
717 }
718
719 /* Pass an object-like macro a hexadecimal floating-point value.  */
720 static void
721 builtin_define_with_hex_fp_value (const char *macro,
722                                   tree type ATTRIBUTE_UNUSED, int digits,
723                                   const char *hex_str, 
724                                   const char *fp_suffix,
725                                   const char *fp_cast)
726 {
727   REAL_VALUE_TYPE real;
728   char dec_str[64], buf1[256], buf2[256];
729
730   /* Hex values are really cool and convenient, except that they're
731      not supported in strict ISO C90 mode.  First, the "p-" sequence
732      is not valid as part of a preprocessor number.  Second, we get a
733      pedwarn from the preprocessor, which has no context, so we can't
734      suppress the warning with __extension__.
735
736      So instead what we do is construct the number in hex (because
737      it's easy to get the exact correct value), parse it as a real,
738      then print it back out as decimal.  */
739
740   real_from_string (&real, hex_str);
741   real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
742
743   /* Assemble the macro in the following fashion
744      macro = fp_cast [dec_str fp_suffix] */
745   sprintf (buf1, "%s%s", dec_str, fp_suffix);
746   sprintf (buf2, fp_cast, buf1);
747   sprintf (buf1, "%s=%s", macro, buf2);
748   
749   cpp_define (parse_in, buf1);
750 }
751
752 /* Define MAX for TYPE based on the precision of the type.  IS_LONG is
753    1 for type "long" and 2 for "long long".  We have to handle
754    unsigned types, since wchar_t might be unsigned.  */
755
756 static void
757 builtin_define_type_max (const char *macro, tree type, int is_long)
758 {
759   static const char *const values[]
760     = { "127", "255",
761         "32767", "65535",
762         "2147483647", "4294967295",
763         "9223372036854775807", "18446744073709551615",
764         "170141183460469231731687303715884105727",
765         "340282366920938463463374607431768211455" };
766   static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
767
768   const char *value, *suffix;
769   char *buf;
770   size_t idx;
771
772   /* Pre-rendering the values mean we don't have to futz with printing a
773      multi-word decimal value.  There are also a very limited number of
774      precisions that we support, so it's really a waste of time.  */
775   switch (TYPE_PRECISION (type))
776     {
777     case 8:     idx = 0; break;
778     case 16:    idx = 2; break;
779     case 32:    idx = 4; break;
780     case 64:    idx = 6; break;
781     case 128:   idx = 8; break;
782     default:    gcc_unreachable ();
783     }
784
785   value = values[idx + TYPE_UNSIGNED (type)];
786   suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
787
788   buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
789                          + strlen (suffix) + 1);
790   sprintf (buf, "%s=%s%s", macro, value, suffix);
791
792   cpp_define (parse_in, buf);
793 }