1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 2, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #include "coretypes.h"
31 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
33 #include "tm_p.h" /* Target prototypes. */
35 #ifndef REGISTER_PREFIX
36 #define REGISTER_PREFIX ""
39 /* Non-static as some targets don't use it. */
40 void builtin_define_std
PARAMS ((const char *)) ATTRIBUTE_UNUSED
;
41 static void builtin_define_with_value_n
PARAMS ((const char *, const char *,
43 static void builtin_define_with_int_value
PARAMS ((const char *,
45 static void builtin_define_with_hex_fp_value
PARAMS ((const char *, tree
,
48 static void builtin_define_type_max
PARAMS ((const char *, tree
, int));
49 static void builtin_define_type_precision
PARAMS ((const char *, tree
));
50 static void builtin_define_float_constants
PARAMS ((const char *,
52 static void define__GNUC__
PARAMS ((void));
54 /* Define NAME with value TYPE precision. */
56 builtin_define_type_precision (name
, type
)
60 builtin_define_with_int_value (name
, TYPE_PRECISION (type
));
63 /* Define the float.h constants for TYPE using NAME_PREFIX and FP_SUFFIX. */
65 builtin_define_float_constants (name_prefix
, fp_suffix
, type
)
66 const char *name_prefix
;
67 const char *fp_suffix
;
70 /* Used to convert radix-based values to base 10 values in several cases.
72 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
73 least 6 significant digits for correct results. Using the fraction
74 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
75 intermediate; perhaps someone can find a better approximation, in the
76 mean time, I suspect using doubles won't harm the bootstrap here. */
78 const double log10_2
= .30102999566398119521;
80 const struct real_format
*fmt
;
82 char name
[64], buf
[128];
83 int dig
, min_10_exp
, max_10_exp
;
86 fmt
= real_format_for_mode
[TYPE_MODE (type
) - QFmode
];
88 /* The radix of the exponent representation. */
89 if (type
== float_type_node
)
90 builtin_define_with_int_value ("__FLT_RADIX__", fmt
->b
);
91 log10_b
= log10_2
* fmt
->log2_b
;
93 /* The number of radix digits, p, in the floating-point significand. */
94 sprintf (name
, "__%s_MANT_DIG__", name_prefix
);
95 builtin_define_with_int_value (name
, fmt
->p
);
97 /* The number of decimal digits, q, such that any floating-point number
98 with q decimal digits can be rounded into a floating-point number with
99 p radix b digits and back again without change to the q decimal digits,
101 p log10 b if b is a power of 10
102 floor((p - 1) log10 b) otherwise
104 dig
= (fmt
->p
- 1) * log10_b
;
105 sprintf (name
, "__%s_DIG__", name_prefix
);
106 builtin_define_with_int_value (name
, dig
);
108 /* The minimum negative int x such that b**(x-1) is a normalized float. */
109 sprintf (name
, "__%s_MIN_EXP__", name_prefix
);
110 sprintf (buf
, "(%d)", fmt
->emin
);
111 builtin_define_with_value (name
, buf
, 0);
113 /* The minimum negative int x such that 10**x is a normalized float,
115 ceil (log10 (b ** (emin - 1)))
116 = ceil (log10 (b) * (emin - 1))
118 Recall that emin is negative, so the integer truncation calculates
119 the ceiling, not the floor, in this case. */
120 min_10_exp
= (fmt
->emin
- 1) * log10_b
;
121 sprintf (name
, "__%s_MIN_10_EXP__", name_prefix
);
122 sprintf (buf
, "(%d)", min_10_exp
);
123 builtin_define_with_value (name
, buf
, 0);
125 /* The maximum int x such that b**(x-1) is a representable float. */
126 sprintf (name
, "__%s_MAX_EXP__", name_prefix
);
127 builtin_define_with_int_value (name
, fmt
->emax
);
129 /* The maximum int x such that 10**x is in the range of representable
130 finite floating-point numbers,
132 floor (log10((1 - b**-p) * b**emax))
133 = floor (log10(1 - b**-p) + log10(b**emax))
134 = floor (log10(1 - b**-p) + log10(b)*emax)
136 The safest thing to do here is to just compute this number. But since
137 we don't link cc1 with libm, we cannot. We could implement log10 here
138 a series expansion, but that seems too much effort because:
140 Note that the first term, for all extant p, is a number exceedingly close
141 to zero, but slightly negative. Note that the second term is an integer
142 scaling an irrational number, and that because of the floor we are only
143 interested in its integral portion.
145 In order for the first term to have any effect on the integral portion
146 of the second term, the second term has to be exceedingly close to an
147 integer itself (e.g. 123.000000000001 or something). Getting a result
148 that close to an integer requires that the irrational multiplicand have
149 a long series of zeros in its expansion, which doesn't occur in the
150 first 20 digits or so of log10(b).
152 Hand-waving aside, crunching all of the sets of constants above by hand
153 does not yield a case for which the first term is significant, which
154 in the end is all that matters. */
155 max_10_exp
= fmt
->emax
* log10_b
;
156 sprintf (name
, "__%s_MAX_10_EXP__", name_prefix
);
157 builtin_define_with_int_value (name
, max_10_exp
);
159 /* The number of decimal digits, n, such that any floating-point number
160 can be rounded to n decimal digits and back again without change to
163 p * log10(b) if b is a power of 10
164 ceil(1 + p * log10(b)) otherwise
166 The only macro we care about is this number for the widest supported
167 floating type, but we want this value for rendering constants below. */
169 double d_decimal_dig
= 1 + fmt
->p
* log10_b
;
170 decimal_dig
= d_decimal_dig
;
171 if (decimal_dig
< d_decimal_dig
)
174 if (type
== long_double_type_node
)
175 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig
);
177 /* Since, for the supported formats, B is always a power of 2, we
178 construct the following numbers directly as a hexadecimal
181 /* The maximum representable finite floating-point number,
182 (1 - b**-p) * b**emax */
187 strcpy (buf
, "0x0.");
188 n
= fmt
->p
* fmt
->log2_b
;
189 for (i
= 0, p
= buf
+ 4; i
+ 3 < n
; i
+= 4)
192 *p
++ = "08ce"[n
- i
];
193 sprintf (p
, "p%d", fmt
->emax
* fmt
->log2_b
);
195 sprintf (name
, "__%s_MAX__", name_prefix
);
196 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
198 /* The minimum normalized positive floating-point number,
200 sprintf (name
, "__%s_MIN__", name_prefix
);
201 sprintf (buf
, "0x1p%d", (fmt
->emin
- 1) * fmt
->log2_b
);
202 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
204 /* The difference between 1 and the least value greater than 1 that is
205 representable in the given floating point type, b**(1-p). */
206 sprintf (name
, "__%s_EPSILON__", name_prefix
);
207 sprintf (buf
, "0x1p%d", (1 - fmt
->p
) * fmt
->log2_b
);
208 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
, buf
, fp_suffix
);
210 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
211 positive floating-point number, b**(emin-p). Zero for formats that
212 don't support denormals. */
213 sprintf (name
, "__%s_DENORM_MIN__", name_prefix
);
216 sprintf (buf
, "0x1p%d", (fmt
->emin
- fmt
->p
) * fmt
->log2_b
);
217 builtin_define_with_hex_fp_value (name
, type
, decimal_dig
,
222 sprintf (buf
, "0.0%s", fp_suffix
);
223 builtin_define_with_value (name
, buf
, 0);
226 /* For C++ std::numeric_limits<T>::has_infinity. */
227 sprintf (name
, "__%s_HAS_INFINITY__", name_prefix
);
228 builtin_define_with_int_value (name
,
229 MODE_HAS_INFINITIES (TYPE_MODE (type
)));
230 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
231 predicate to distinguish a target that has both quiet and
232 signalling NaNs from a target that has only quiet NaNs or only
233 signalling NaNs, so we assume that a target that has any kind of
234 NaN has quiet NaNs. */
235 sprintf (name
, "__%s_HAS_QUIET_NAN__", name_prefix
);
236 builtin_define_with_int_value (name
, MODE_HAS_NANS (TYPE_MODE (type
)));
239 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
243 /* The format of the version string, enforced below, is
244 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
245 const char *q
, *v
= version_string
;
247 while (*v
&& ! ISDIGIT (*v
))
249 if (!*v
|| (v
> version_string
&& v
[-1] != '-'))
255 builtin_define_with_value_n ("__GNUC__", q
, v
- q
);
256 if (c_language
== clk_cplusplus
)
257 builtin_define_with_value_n ("__GNUG__", q
, v
- q
);
259 if (*v
!= '.' || !ISDIGIT (v
[1]))
264 builtin_define_with_value_n ("__GNUC_MINOR__", q
, v
- q
);
273 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q
, v
- q
);
276 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
278 if (*v
&& *v
!= ' ' && *v
!= '-')
282 /* Hook that registers front end and target-specific built-ins. */
284 c_cpp_builtins (pfile
)
287 /* -undef turns off target-specific built-ins. */
293 /* For stddef.h. They require macros defined in c-common.c. */
294 c_stddef_cpp_builtins ();
296 if (c_language
== clk_cplusplus
)
298 if (SUPPORTS_ONE_ONLY
)
299 cpp_define (pfile
, "__GXX_WEAK__=1");
301 cpp_define (pfile
, "__GXX_WEAK__=0");
303 cpp_define (pfile
, "__EXCEPTIONS");
305 cpp_define (pfile
, "__DEPRECATED");
308 /* represents the C++ ABI version, always defined so it can be used while
309 preprocessing C and assembler. */
310 cpp_define (pfile
, "__GXX_ABI_VERSION=102");
312 /* libgcc needs to know this. */
313 if (USING_SJLJ_EXCEPTIONS
)
314 cpp_define (pfile
, "__USING_SJLJ_EXCEPTIONS__");
316 /* limits.h needs to know these. */
317 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node
, 0);
318 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node
, 0);
319 builtin_define_type_max ("__INT_MAX__", integer_type_node
, 0);
320 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node
, 1);
321 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node
, 2);
322 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node
, 0);
324 builtin_define_type_precision ("__CHAR_BIT__", char_type_node
);
326 /* float.h needs to know these. */
328 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
329 TARGET_FLT_EVAL_METHOD
);
331 builtin_define_float_constants ("FLT", "F", float_type_node
);
332 builtin_define_float_constants ("DBL", "", double_type_node
);
333 builtin_define_float_constants ("LDBL", "L", long_double_type_node
);
335 /* For use in assembly language. */
336 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX
, 0);
337 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix
, 0);
340 builtin_define_with_value ("__VERSION__", version_string
, 1);
342 /* Definitions for LP64 model. */
343 if (TYPE_PRECISION (long_integer_type_node
) == 64
344 && POINTER_SIZE
== 64
345 && TYPE_PRECISION (integer_type_node
) == 32)
347 cpp_define (pfile
, "_LP64");
348 cpp_define (pfile
, "__LP64__");
351 /* Other target-independent built-ins determined by command-line
354 cpp_define (pfile
, "__OPTIMIZE_SIZE__");
356 cpp_define (pfile
, "__OPTIMIZE__");
358 if (fast_math_flags_set_p ())
359 cpp_define (pfile
, "__FAST_MATH__");
360 if (flag_really_no_inline
)
361 cpp_define (pfile
, "__NO_INLINE__");
362 if (flag_signaling_nans
)
363 cpp_define (pfile
, "__SUPPORT_SNAN__");
364 if (flag_finite_math_only
)
365 cpp_define (pfile
, "__FINITE_MATH_ONLY__=1");
367 cpp_define (pfile
, "__FINITE_MATH_ONLY__=0");
370 cpp_define (pfile
, "__STRICT_ANSI__");
372 if (!flag_signed_char
)
373 cpp_define (pfile
, "__CHAR_UNSIGNED__");
375 if (c_language
== clk_cplusplus
&& TREE_UNSIGNED (wchar_type_node
))
376 cpp_define (pfile
, "__WCHAR_UNSIGNED__");
378 /* Make the choice of ObjC runtime visible to source code. */
379 if (flag_objc
&& flag_next_runtime
)
380 cpp_define (pfile
, "__NEXT_RUNTIME__");
382 /* A straightforward target hook doesn't work, because of problems
383 linking that hook's body when part of non-C front ends. */
384 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
385 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
386 # define builtin_define(TXT) cpp_define (pfile, TXT)
387 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
388 TARGET_CPU_CPP_BUILTINS ();
389 TARGET_OS_CPP_BUILTINS ();
392 /* Pass an object-like macro. If it doesn't lie in the user's
393 namespace, defines it unconditionally. Otherwise define a version
394 with two leading underscores, and another version with two leading
395 and trailing underscores, and define the original only if an ISO
396 standard was not nominated.
398 e.g. passing "unix" defines "__unix", "__unix__" and possibly
399 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
402 builtin_define_std (macro
)
405 size_t len
= strlen (macro
);
406 char *buff
= alloca (len
+ 5);
410 /* prepend __ (or maybe just _) if in user's namespace. */
411 memcpy (p
, macro
, len
+ 1);
412 if (!( *p
== '_' && (p
[1] == '_' || ISUPPER (p
[1]))))
419 cpp_define (parse_in
, p
);
421 /* If it was in user's namespace... */
424 /* Define the macro with leading and following __. */
430 cpp_define (parse_in
, p
);
432 /* Finally, define the original macro if permitted. */
434 cpp_define (parse_in
, macro
);
438 /* Pass an object-like macro and a value to define it to. The third
439 parameter says whether or not to turn the value into a string
442 builtin_define_with_value (macro
, expansion
, is_str
)
444 const char *expansion
;
448 size_t mlen
= strlen (macro
);
449 size_t elen
= strlen (expansion
);
450 size_t extra
= 2; /* space for an = and a NUL */
453 extra
+= 2; /* space for two quote marks */
455 buf
= alloca (mlen
+ elen
+ extra
);
457 sprintf (buf
, "%s=\"%s\"", macro
, expansion
);
459 sprintf (buf
, "%s=%s", macro
, expansion
);
461 cpp_define (parse_in
, buf
);
464 /* Pass an object-like macro and a value to define it to. The third
465 parameter is the length of the expansion. */
467 builtin_define_with_value_n (macro
, expansion
, elen
)
469 const char *expansion
;
473 size_t mlen
= strlen (macro
);
475 /* Space for an = and a NUL. */
476 buf
= alloca (mlen
+ elen
+ 2);
477 memcpy (buf
, macro
, mlen
);
479 memcpy (buf
+ mlen
+ 1, expansion
, elen
);
480 buf
[mlen
+ elen
+ 1] = '\0';
482 cpp_define (parse_in
, buf
);
485 /* Pass an object-like macro and an integer value to define it to. */
487 builtin_define_with_int_value (macro
, value
)
492 size_t mlen
= strlen (macro
);
494 size_t extra
= 2; /* space for = and NUL. */
496 buf
= alloca (mlen
+ vlen
+ extra
);
497 memcpy (buf
, macro
, mlen
);
499 sprintf (buf
+ mlen
+ 1, HOST_WIDE_INT_PRINT_DEC
, value
);
501 cpp_define (parse_in
, buf
);
504 /* Pass an object-like macro a hexadecimal floating-point value. */
506 builtin_define_with_hex_fp_value (macro
, type
, digits
, hex_str
, fp_suffix
)
508 tree type ATTRIBUTE_UNUSED
;
511 const char *fp_suffix
;
513 REAL_VALUE_TYPE real
;
514 char dec_str
[64], buf
[256];
516 /* Hex values are really cool and convenient, except that they're
517 not supported in strict ISO C90 mode. First, the "p-" sequence
518 is not valid as part of a preprocessor number. Second, we get a
519 pedwarn from the preprocessor, which has no context, so we can't
520 suppress the warning with __extension__.
522 So instead what we do is construct the number in hex (because
523 it's easy to get the exact correct value), parse it as a real,
524 then print it back out as decimal. */
526 real_from_string (&real
, hex_str
);
527 real_to_decimal (dec_str
, &real
, sizeof (dec_str
), digits
, 0);
529 sprintf (buf
, "%s=%s%s", macro
, dec_str
, fp_suffix
);
530 cpp_define (parse_in
, buf
);
533 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
534 1 for type "long" and 2 for "long long". We have to handle
535 unsigned types, since wchar_t might be unsigned. */
538 builtin_define_type_max (macro
, type
, is_long
)
543 static const char *const values
[]
546 "2147483647", "4294967295",
547 "9223372036854775807", "18446744073709551615",
548 "170141183460469231731687303715884105727",
549 "340282366920938463463374607431768211455" };
550 static const char *const suffixes
[] = { "", "U", "L", "UL", "LL", "ULL" };
552 const char *value
, *suffix
;
556 /* Pre-rendering the values mean we don't have to futz with printing a
557 multi-word decimal value. There are also a very limited number of
558 precisions that we support, so it's really a waste of time. */
559 switch (TYPE_PRECISION (type
))
561 case 8: idx
= 0; break;
562 case 16: idx
= 2; break;
563 case 32: idx
= 4; break;
564 case 64: idx
= 6; break;
565 case 128: idx
= 8; break;
569 value
= values
[idx
+ TREE_UNSIGNED (type
)];
570 suffix
= suffixes
[is_long
* 2 + TREE_UNSIGNED (type
)];
572 buf
= alloca (strlen (macro
) + 1 + strlen (value
) + strlen (suffix
) + 1);
573 sprintf (buf
, "%s=%s%s", macro
, value
, suffix
);
575 cpp_define (parse_in
, buf
);