]>
Commit | Line | Data |
---|---|---|
cb60f38d | 1 | /* Define builtin-in macros for the C family front ends. |
ad616de1 | 2 | Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. |
cb60f38d NB |
3 | |
4 | This file is part of GCC. | |
5 | ||
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 | |
9 | version. | |
10 | ||
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 | |
14 | for more details. | |
15 | ||
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 | |
366ccddb KC |
18 | Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA |
19 | 02110-1301, USA. */ | |
cb60f38d NB |
20 | |
21 | #include "config.h" | |
22 | #include "system.h" | |
23 | #include "coretypes.h" | |
24 | #include "tm.h" | |
25 | #include "tree.h" | |
a757585a | 26 | #include "version.h" |
cb60f38d NB |
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 "toplev.h" | |
cd6a5007 | 34 | #include "tm_p.h" /* Target prototypes. */ |
84b8b0e0 | 35 | #include "target.h" |
cb60f38d | 36 | |
4e2e315f NB |
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 | ||
cb60f38d NB |
45 | #ifndef REGISTER_PREFIX |
46 | #define REGISTER_PREFIX "" | |
47 | #endif | |
48 | ||
21282b1e | 49 | /* Non-static as some targets don't use it. */ |
35b1a6fa AJ |
50 | void builtin_define_std (const char *) ATTRIBUTE_UNUSED; |
51 | static void builtin_define_with_value_n (const char *, const char *, | |
52 | size_t); | |
53 | static void builtin_define_with_int_value (const char *, HOST_WIDE_INT); | |
54 | static void builtin_define_with_hex_fp_value (const char *, tree, | |
55 | int, const char *, | |
264c41ed | 56 | const char *, |
35b1a6fa | 57 | const char *); |
85291069 | 58 | static void builtin_define_stdint_macros (void); |
35b1a6fa AJ |
59 | static void builtin_define_type_max (const char *, tree, int); |
60 | static void builtin_define_type_precision (const char *, tree); | |
264c41ed CD |
61 | static void builtin_define_float_constants (const char *, |
62 | const char *, | |
63 | const char *, | |
35b1a6fa AJ |
64 | tree); |
65 | static void define__GNUC__ (void); | |
cb60f38d NB |
66 | |
67 | /* Define NAME with value TYPE precision. */ | |
68 | static void | |
35b1a6fa | 69 | builtin_define_type_precision (const char *name, tree type) |
cb60f38d NB |
70 | { |
71 | builtin_define_with_int_value (name, TYPE_PRECISION (type)); | |
72 | } | |
73 | ||
264c41ed CD |
74 | /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX, |
75 | and FP_CAST. */ | |
cb60f38d | 76 | static void |
264c41ed CD |
77 | builtin_define_float_constants (const char *name_prefix, |
78 | const char *fp_suffix, | |
79 | const char *fp_cast, | |
80 | tree type) | |
cb60f38d NB |
81 | { |
82 | /* Used to convert radix-based values to base 10 values in several cases. | |
83 | ||
84 | In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at | |
85 | least 6 significant digits for correct results. Using the fraction | |
86 | formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an | |
87 | intermediate; perhaps someone can find a better approximation, in the | |
88 | mean time, I suspect using doubles won't harm the bootstrap here. */ | |
89 | ||
90 | const double log10_2 = .30102999566398119521; | |
91 | double log10_b; | |
92 | const struct real_format *fmt; | |
93 | ||
94 | char name[64], buf[128]; | |
95 | int dig, min_10_exp, max_10_exp; | |
96 | int decimal_dig; | |
97 | ||
70a01792 | 98 | fmt = REAL_MODE_FORMAT (TYPE_MODE (type)); |
cb60f38d NB |
99 | |
100 | /* The radix of the exponent representation. */ | |
101 | if (type == float_type_node) | |
102 | builtin_define_with_int_value ("__FLT_RADIX__", fmt->b); | |
103 | log10_b = log10_2 * fmt->log2_b; | |
104 | ||
105 | /* The number of radix digits, p, in the floating-point significand. */ | |
106 | sprintf (name, "__%s_MANT_DIG__", name_prefix); | |
107 | builtin_define_with_int_value (name, fmt->p); | |
108 | ||
109 | /* The number of decimal digits, q, such that any floating-point number | |
110 | with q decimal digits can be rounded into a floating-point number with | |
111 | p radix b digits and back again without change to the q decimal digits, | |
112 | ||
113 | p log10 b if b is a power of 10 | |
35b1a6fa | 114 | floor((p - 1) log10 b) otherwise |
cb60f38d NB |
115 | */ |
116 | dig = (fmt->p - 1) * log10_b; | |
117 | sprintf (name, "__%s_DIG__", name_prefix); | |
118 | builtin_define_with_int_value (name, dig); | |
119 | ||
120 | /* The minimum negative int x such that b**(x-1) is a normalized float. */ | |
121 | sprintf (name, "__%s_MIN_EXP__", name_prefix); | |
122 | sprintf (buf, "(%d)", fmt->emin); | |
123 | builtin_define_with_value (name, buf, 0); | |
124 | ||
125 | /* The minimum negative int x such that 10**x is a normalized float, | |
126 | ||
127 | ceil (log10 (b ** (emin - 1))) | |
128 | = ceil (log10 (b) * (emin - 1)) | |
129 | ||
130 | Recall that emin is negative, so the integer truncation calculates | |
131 | the ceiling, not the floor, in this case. */ | |
132 | min_10_exp = (fmt->emin - 1) * log10_b; | |
133 | sprintf (name, "__%s_MIN_10_EXP__", name_prefix); | |
134 | sprintf (buf, "(%d)", min_10_exp); | |
135 | builtin_define_with_value (name, buf, 0); | |
136 | ||
137 | /* The maximum int x such that b**(x-1) is a representable float. */ | |
138 | sprintf (name, "__%s_MAX_EXP__", name_prefix); | |
139 | builtin_define_with_int_value (name, fmt->emax); | |
140 | ||
141 | /* The maximum int x such that 10**x is in the range of representable | |
142 | finite floating-point numbers, | |
143 | ||
144 | floor (log10((1 - b**-p) * b**emax)) | |
145 | = floor (log10(1 - b**-p) + log10(b**emax)) | |
146 | = floor (log10(1 - b**-p) + log10(b)*emax) | |
147 | ||
148 | The safest thing to do here is to just compute this number. But since | |
149 | we don't link cc1 with libm, we cannot. We could implement log10 here | |
150 | a series expansion, but that seems too much effort because: | |
151 | ||
152 | Note that the first term, for all extant p, is a number exceedingly close | |
153 | to zero, but slightly negative. Note that the second term is an integer | |
154 | scaling an irrational number, and that because of the floor we are only | |
155 | interested in its integral portion. | |
156 | ||
157 | In order for the first term to have any effect on the integral portion | |
158 | of the second term, the second term has to be exceedingly close to an | |
159 | integer itself (e.g. 123.000000000001 or something). Getting a result | |
160 | that close to an integer requires that the irrational multiplicand have | |
161 | a long series of zeros in its expansion, which doesn't occur in the | |
162 | first 20 digits or so of log10(b). | |
163 | ||
164 | Hand-waving aside, crunching all of the sets of constants above by hand | |
165 | does not yield a case for which the first term is significant, which | |
166 | in the end is all that matters. */ | |
167 | max_10_exp = fmt->emax * log10_b; | |
168 | sprintf (name, "__%s_MAX_10_EXP__", name_prefix); | |
169 | builtin_define_with_int_value (name, max_10_exp); | |
170 | ||
171 | /* The number of decimal digits, n, such that any floating-point number | |
172 | can be rounded to n decimal digits and back again without change to | |
35b1a6fa | 173 | the value. |
cb60f38d NB |
174 | |
175 | p * log10(b) if b is a power of 10 | |
176 | ceil(1 + p * log10(b)) otherwise | |
177 | ||
178 | The only macro we care about is this number for the widest supported | |
179 | floating type, but we want this value for rendering constants below. */ | |
180 | { | |
181 | double d_decimal_dig = 1 + fmt->p * log10_b; | |
182 | decimal_dig = d_decimal_dig; | |
183 | if (decimal_dig < d_decimal_dig) | |
184 | decimal_dig++; | |
185 | } | |
186 | if (type == long_double_type_node) | |
187 | builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig); | |
188 | ||
189 | /* Since, for the supported formats, B is always a power of 2, we | |
190 | construct the following numbers directly as a hexadecimal | |
191 | constants. */ | |
192 | ||
193 | /* The maximum representable finite floating-point number, | |
194 | (1 - b**-p) * b**emax */ | |
195 | { | |
196 | int i, n; | |
197 | char *p; | |
198 | ||
199 | strcpy (buf, "0x0."); | |
200 | n = fmt->p * fmt->log2_b; | |
201 | for (i = 0, p = buf + 4; i + 3 < n; i += 4) | |
202 | *p++ = 'f'; | |
203 | if (i < n) | |
204 | *p++ = "08ce"[n - i]; | |
205 | sprintf (p, "p%d", fmt->emax * fmt->log2_b); | |
ddc68564 AM |
206 | if (fmt->pnan < fmt->p) |
207 | { | |
208 | /* This is an IBM extended double format made up of two IEEE | |
209 | doubles. The value of the long double is the sum of the | |
210 | values of the two parts. The most significant part is | |
211 | required to be the value of the long double rounded to the | |
212 | nearest double. Rounding means we need a slightly smaller | |
213 | value for LDBL_MAX. */ | |
214 | buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4]; | |
215 | } | |
cb60f38d NB |
216 | } |
217 | sprintf (name, "__%s_MAX__", name_prefix); | |
264c41ed | 218 | builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); |
cb60f38d NB |
219 | |
220 | /* The minimum normalized positive floating-point number, | |
221 | b**(emin-1). */ | |
222 | sprintf (name, "__%s_MIN__", name_prefix); | |
223 | sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b); | |
264c41ed | 224 | builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); |
cb60f38d NB |
225 | |
226 | /* The difference between 1 and the least value greater than 1 that is | |
227 | representable in the given floating point type, b**(1-p). */ | |
228 | sprintf (name, "__%s_EPSILON__", name_prefix); | |
59d7d767 GK |
229 | if (fmt->pnan < fmt->p) |
230 | /* This is an IBM extended double format, so 1.0 + any double is | |
231 | representable precisely. */ | |
232 | sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b); | |
233 | else | |
234 | sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b); | |
264c41ed | 235 | builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast); |
cb60f38d NB |
236 | |
237 | /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized | |
238 | positive floating-point number, b**(emin-p). Zero for formats that | |
239 | don't support denormals. */ | |
240 | sprintf (name, "__%s_DENORM_MIN__", name_prefix); | |
241 | if (fmt->has_denorm) | |
242 | { | |
243 | sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b); | |
244 | builtin_define_with_hex_fp_value (name, type, decimal_dig, | |
264c41ed | 245 | buf, fp_suffix, fp_cast); |
cb60f38d NB |
246 | } |
247 | else | |
248 | { | |
249 | sprintf (buf, "0.0%s", fp_suffix); | |
250 | builtin_define_with_value (name, buf, 0); | |
251 | } | |
252 | ||
264c41ed CD |
253 | sprintf (name, "__%s_HAS_DENORM__", name_prefix); |
254 | builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0); | |
255 | ||
cb60f38d NB |
256 | /* For C++ std::numeric_limits<T>::has_infinity. */ |
257 | sprintf (name, "__%s_HAS_INFINITY__", name_prefix); | |
35b1a6fa | 258 | builtin_define_with_int_value (name, |
cb60f38d NB |
259 | MODE_HAS_INFINITIES (TYPE_MODE (type))); |
260 | /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a | |
261 | predicate to distinguish a target that has both quiet and | |
262 | signalling NaNs from a target that has only quiet NaNs or only | |
263 | signalling NaNs, so we assume that a target that has any kind of | |
264 | NaN has quiet NaNs. */ | |
265 | sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix); | |
266 | builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type))); | |
267 | } | |
268 | ||
269 | /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */ | |
270 | static void | |
35b1a6fa | 271 | define__GNUC__ (void) |
cb60f38d NB |
272 | { |
273 | /* The format of the version string, enforced below, is | |
274 | ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */ | |
275 | const char *q, *v = version_string; | |
276 | ||
3f75a254 | 277 | while (*v && !ISDIGIT (*v)) |
cb60f38d | 278 | v++; |
366de0ce | 279 | gcc_assert (*v && (v <= version_string || v[-1] == '-')); |
cb60f38d NB |
280 | |
281 | q = v; | |
282 | while (ISDIGIT (*v)) | |
283 | v++; | |
284 | builtin_define_with_value_n ("__GNUC__", q, v - q); | |
37fa72e9 | 285 | if (c_dialect_cxx ()) |
cb60f38d NB |
286 | builtin_define_with_value_n ("__GNUG__", q, v - q); |
287 | ||
a101957b | 288 | gcc_assert (*v == '.' && ISDIGIT (v[1])); |
366de0ce | 289 | |
cb60f38d NB |
290 | q = ++v; |
291 | while (ISDIGIT (*v)) | |
292 | v++; | |
293 | builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q); | |
294 | ||
295 | if (*v == '.') | |
296 | { | |
366de0ce | 297 | gcc_assert (ISDIGIT (v[1])); |
cb60f38d NB |
298 | q = ++v; |
299 | while (ISDIGIT (*v)) | |
300 | v++; | |
301 | builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q); | |
302 | } | |
303 | else | |
304 | builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1); | |
305 | ||
366de0ce | 306 | gcc_assert (!*v || *v == ' ' || *v == '-'); |
cb60f38d NB |
307 | } |
308 | ||
85291069 JM |
309 | /* Define macros used by <stdint.h>. Currently only defines limits |
310 | for intmax_t, used by the testsuite. */ | |
311 | static void | |
312 | builtin_define_stdint_macros (void) | |
313 | { | |
314 | int intmax_long; | |
315 | if (intmax_type_node == long_long_integer_type_node) | |
316 | intmax_long = 2; | |
317 | else if (intmax_type_node == long_integer_type_node) | |
318 | intmax_long = 1; | |
319 | else if (intmax_type_node == integer_type_node) | |
320 | intmax_long = 0; | |
321 | else | |
366de0ce | 322 | gcc_unreachable (); |
85291069 JM |
323 | builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long); |
324 | } | |
325 | ||
cb60f38d NB |
326 | /* Hook that registers front end and target-specific built-ins. */ |
327 | void | |
35b1a6fa | 328 | c_cpp_builtins (cpp_reader *pfile) |
cb60f38d NB |
329 | { |
330 | /* -undef turns off target-specific built-ins. */ | |
331 | if (flag_undef) | |
332 | return; | |
333 | ||
334 | define__GNUC__ (); | |
335 | ||
336 | /* For stddef.h. They require macros defined in c-common.c. */ | |
337 | c_stddef_cpp_builtins (); | |
338 | ||
37fa72e9 | 339 | if (c_dialect_cxx ()) |
cb60f38d | 340 | { |
aee7846e | 341 | if (flag_weak && SUPPORTS_ONE_ONLY) |
cb60f38d NB |
342 | cpp_define (pfile, "__GXX_WEAK__=1"); |
343 | else | |
344 | cpp_define (pfile, "__GXX_WEAK__=0"); | |
cb60f38d NB |
345 | if (warn_deprecated) |
346 | cpp_define (pfile, "__DEPRECATED"); | |
347 | } | |
6cd77c3f RH |
348 | /* Note that we define this for C as well, so that we know if |
349 | __attribute__((cleanup)) will interface with EH. */ | |
2288bdbb RH |
350 | if (flag_exceptions) |
351 | cpp_define (pfile, "__EXCEPTIONS"); | |
cb60f38d | 352 | |
e0a21ab9 | 353 | /* Represents the C++ ABI version, always defined so it can be used while |
cb60f38d | 354 | preprocessing C and assembler. */ |
57702a80 MM |
355 | if (flag_abi_version == 0) |
356 | /* Use a very large value so that: | |
357 | ||
358 | #if __GXX_ABI_VERSION >= <value for version X> | |
359 | ||
360 | will work whether the user explicitly says "-fabi-version=x" or | |
361 | "-fabi-version=0". Do not use INT_MAX because that will be | |
362 | different from system to system. */ | |
363 | builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999); | |
364 | else if (flag_abi_version == 1) | |
1f838355 | 365 | /* Due to a historical accident, this version had the value |
57702a80 MM |
366 | "102". */ |
367 | builtin_define_with_int_value ("__GXX_ABI_VERSION", 102); | |
368 | else | |
e0a21ab9 | 369 | /* Newer versions have values 1002, 1003, .... */ |
57702a80 MM |
370 | builtin_define_with_int_value ("__GXX_ABI_VERSION", |
371 | 1000 + flag_abi_version); | |
cb60f38d NB |
372 | |
373 | /* libgcc needs to know this. */ | |
374 | if (USING_SJLJ_EXCEPTIONS) | |
375 | cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__"); | |
376 | ||
377 | /* limits.h needs to know these. */ | |
378 | builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0); | |
379 | builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0); | |
380 | builtin_define_type_max ("__INT_MAX__", integer_type_node, 0); | |
381 | builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1); | |
382 | builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2); | |
383 | builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0); | |
384 | ||
385 | builtin_define_type_precision ("__CHAR_BIT__", char_type_node); | |
386 | ||
85291069 JM |
387 | /* stdint.h (eventually) and the testsuite need to know these. */ |
388 | builtin_define_stdint_macros (); | |
389 | ||
cb60f38d NB |
390 | /* float.h needs to know these. */ |
391 | ||
392 | builtin_define_with_int_value ("__FLT_EVAL_METHOD__", | |
393 | TARGET_FLT_EVAL_METHOD); | |
394 | ||
264c41ed CD |
395 | builtin_define_float_constants ("FLT", "F", "%s", float_type_node); |
396 | /* Cast the double precision constants when single precision constants are | |
397 | specified. The correct result is computed by the compiler when using | |
398 | macros that include a cast. This has the side-effect of making the value | |
399 | unusable in const expressions. */ | |
400 | if (flag_single_precision_constant) | |
401 | builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node); | |
402 | else | |
403 | builtin_define_float_constants ("DBL", "", "%s", double_type_node); | |
404 | builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node); | |
cb60f38d NB |
405 | |
406 | /* For use in assembly language. */ | |
407 | builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0); | |
408 | builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0); | |
409 | ||
410 | /* Misc. */ | |
411 | builtin_define_with_value ("__VERSION__", version_string, 1); | |
412 | ||
00530a21 AJ |
413 | /* Definitions for LP64 model. */ |
414 | if (TYPE_PRECISION (long_integer_type_node) == 64 | |
415 | && POINTER_SIZE == 64 | |
416 | && TYPE_PRECISION (integer_type_node) == 32) | |
417 | { | |
418 | cpp_define (pfile, "_LP64"); | |
419 | cpp_define (pfile, "__LP64__"); | |
420 | } | |
35b1a6fa | 421 | |
cb60f38d NB |
422 | /* Other target-independent built-ins determined by command-line |
423 | options. */ | |
424 | if (optimize_size) | |
425 | cpp_define (pfile, "__OPTIMIZE_SIZE__"); | |
426 | if (optimize) | |
427 | cpp_define (pfile, "__OPTIMIZE__"); | |
428 | ||
cb60f38d NB |
429 | if (fast_math_flags_set_p ()) |
430 | cpp_define (pfile, "__FAST_MATH__"); | |
431 | if (flag_really_no_inline) | |
432 | cpp_define (pfile, "__NO_INLINE__"); | |
433 | if (flag_signaling_nans) | |
434 | cpp_define (pfile, "__SUPPORT_SNAN__"); | |
435 | if (flag_finite_math_only) | |
436 | cpp_define (pfile, "__FINITE_MATH_ONLY__=1"); | |
437 | else | |
438 | cpp_define (pfile, "__FINITE_MATH_ONLY__=0"); | |
3d119f8f KG |
439 | if (flag_pic) |
440 | { | |
441 | builtin_define_with_int_value ("__pic__", flag_pic); | |
442 | builtin_define_with_int_value ("__PIC__", flag_pic); | |
443 | } | |
cb60f38d NB |
444 | |
445 | if (flag_iso) | |
446 | cpp_define (pfile, "__STRICT_ANSI__"); | |
447 | ||
448 | if (!flag_signed_char) | |
449 | cpp_define (pfile, "__CHAR_UNSIGNED__"); | |
450 | ||
8df83eae | 451 | if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node)) |
cb60f38d NB |
452 | cpp_define (pfile, "__WCHAR_UNSIGNED__"); |
453 | ||
454 | /* Make the choice of ObjC runtime visible to source code. */ | |
37fa72e9 | 455 | if (c_dialect_objc () && flag_next_runtime) |
cb60f38d NB |
456 | cpp_define (pfile, "__NEXT_RUNTIME__"); |
457 | ||
84b8b0e0 ZW |
458 | /* Show the availability of some target pragmas. */ |
459 | if (flag_mudflap || targetm.handle_pragma_redefine_extname) | |
460 | cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME"); | |
461 | ||
462 | if (targetm.handle_pragma_extern_prefix) | |
463 | cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX"); | |
464 | ||
0ffb94cd JW |
465 | /* Make the choice of the stack protector runtime visible to source code. |
466 | The macro names and values here were chosen for compatibility with an | |
467 | earlier implementation, i.e. ProPolice. */ | |
7d69de61 RH |
468 | if (flag_stack_protect == 2) |
469 | cpp_define (pfile, "__SSP_ALL__=2"); | |
470 | else if (flag_stack_protect == 1) | |
471 | cpp_define (pfile, "__SSP__=1"); | |
472 | ||
cb60f38d NB |
473 | /* A straightforward target hook doesn't work, because of problems |
474 | linking that hook's body when part of non-C front ends. */ | |
475 | # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM) | |
476 | # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional) | |
477 | # define builtin_define(TXT) cpp_define (pfile, TXT) | |
478 | # define builtin_assert(TXT) cpp_assert (pfile, TXT) | |
479 | TARGET_CPU_CPP_BUILTINS (); | |
480 | TARGET_OS_CPP_BUILTINS (); | |
4e2e315f | 481 | TARGET_OBJFMT_CPP_BUILTINS (); |
63c5b495 MM |
482 | |
483 | /* Support the __declspec keyword by turning them into attributes. | |
484 | Note that the current way we do this may result in a collision | |
485 | with predefined attributes later on. This can be solved by using | |
486 | one attribute, say __declspec__, and passing args to it. The | |
487 | problem with that approach is that args are not accumulated: each | |
488 | new appearance would clobber any existing args. */ | |
489 | if (TARGET_DECLSPEC) | |
490 | builtin_define ("__declspec(x)=__attribute__((x))"); | |
cb60f38d NB |
491 | } |
492 | ||
493 | /* Pass an object-like macro. If it doesn't lie in the user's | |
494 | namespace, defines it unconditionally. Otherwise define a version | |
495 | with two leading underscores, and another version with two leading | |
496 | and trailing underscores, and define the original only if an ISO | |
497 | standard was not nominated. | |
498 | ||
499 | e.g. passing "unix" defines "__unix", "__unix__" and possibly | |
500 | "unix". Passing "_mips" defines "__mips", "__mips__" and possibly | |
501 | "_mips". */ | |
21282b1e | 502 | void |
35b1a6fa | 503 | builtin_define_std (const char *macro) |
cb60f38d NB |
504 | { |
505 | size_t len = strlen (macro); | |
506 | char *buff = alloca (len + 5); | |
507 | char *p = buff + 2; | |
508 | char *q = p + len; | |
509 | ||
510 | /* prepend __ (or maybe just _) if in user's namespace. */ | |
511 | memcpy (p, macro, len + 1); | |
512 | if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1])))) | |
513 | { | |
514 | if (*p != '_') | |
515 | *--p = '_'; | |
516 | if (p[1] != '_') | |
517 | *--p = '_'; | |
518 | } | |
519 | cpp_define (parse_in, p); | |
520 | ||
521 | /* If it was in user's namespace... */ | |
522 | if (p != buff + 2) | |
523 | { | |
524 | /* Define the macro with leading and following __. */ | |
525 | if (q[-1] != '_') | |
526 | *q++ = '_'; | |
527 | if (q[-2] != '_') | |
528 | *q++ = '_'; | |
529 | *q = '\0'; | |
530 | cpp_define (parse_in, p); | |
531 | ||
532 | /* Finally, define the original macro if permitted. */ | |
533 | if (!flag_iso) | |
534 | cpp_define (parse_in, macro); | |
535 | } | |
536 | } | |
537 | ||
538 | /* Pass an object-like macro and a value to define it to. The third | |
539 | parameter says whether or not to turn the value into a string | |
540 | constant. */ | |
541 | void | |
35b1a6fa | 542 | builtin_define_with_value (const char *macro, const char *expansion, int is_str) |
cb60f38d NB |
543 | { |
544 | char *buf; | |
545 | size_t mlen = strlen (macro); | |
546 | size_t elen = strlen (expansion); | |
547 | size_t extra = 2; /* space for an = and a NUL */ | |
548 | ||
549 | if (is_str) | |
550 | extra += 2; /* space for two quote marks */ | |
551 | ||
552 | buf = alloca (mlen + elen + extra); | |
553 | if (is_str) | |
554 | sprintf (buf, "%s=\"%s\"", macro, expansion); | |
555 | else | |
556 | sprintf (buf, "%s=%s", macro, expansion); | |
557 | ||
558 | cpp_define (parse_in, buf); | |
559 | } | |
560 | ||
561 | /* Pass an object-like macro and a value to define it to. The third | |
562 | parameter is the length of the expansion. */ | |
563 | static void | |
35b1a6fa | 564 | builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen) |
cb60f38d NB |
565 | { |
566 | char *buf; | |
567 | size_t mlen = strlen (macro); | |
35b1a6fa | 568 | |
cb60f38d NB |
569 | /* Space for an = and a NUL. */ |
570 | buf = alloca (mlen + elen + 2); | |
571 | memcpy (buf, macro, mlen); | |
6a87d634 | 572 | buf[mlen] = '='; |
cb60f38d NB |
573 | memcpy (buf + mlen + 1, expansion, elen); |
574 | buf[mlen + elen + 1] = '\0'; | |
575 | ||
576 | cpp_define (parse_in, buf); | |
577 | } | |
578 | ||
579 | /* Pass an object-like macro and an integer value to define it to. */ | |
580 | static void | |
35b1a6fa | 581 | builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value) |
cb60f38d NB |
582 | { |
583 | char *buf; | |
584 | size_t mlen = strlen (macro); | |
585 | size_t vlen = 18; | |
586 | size_t extra = 2; /* space for = and NUL. */ | |
587 | ||
588 | buf = alloca (mlen + vlen + extra); | |
589 | memcpy (buf, macro, mlen); | |
590 | buf[mlen] = '='; | |
591 | sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value); | |
592 | ||
593 | cpp_define (parse_in, buf); | |
594 | } | |
595 | ||
596 | /* Pass an object-like macro a hexadecimal floating-point value. */ | |
597 | static void | |
35b1a6fa AJ |
598 | builtin_define_with_hex_fp_value (const char *macro, |
599 | tree type ATTRIBUTE_UNUSED, int digits, | |
264c41ed CD |
600 | const char *hex_str, |
601 | const char *fp_suffix, | |
602 | const char *fp_cast) | |
cb60f38d NB |
603 | { |
604 | REAL_VALUE_TYPE real; | |
264c41ed | 605 | char dec_str[64], buf1[256], buf2[256]; |
cb60f38d NB |
606 | |
607 | /* Hex values are really cool and convenient, except that they're | |
608 | not supported in strict ISO C90 mode. First, the "p-" sequence | |
609 | is not valid as part of a preprocessor number. Second, we get a | |
610 | pedwarn from the preprocessor, which has no context, so we can't | |
611 | suppress the warning with __extension__. | |
612 | ||
35b1a6fa | 613 | So instead what we do is construct the number in hex (because |
cb60f38d NB |
614 | it's easy to get the exact correct value), parse it as a real, |
615 | then print it back out as decimal. */ | |
616 | ||
617 | real_from_string (&real, hex_str); | |
618 | real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0); | |
619 | ||
264c41ed CD |
620 | /* Assemble the macro in the following fashion |
621 | macro = fp_cast [dec_str fp_suffix] */ | |
622 | sprintf (buf1, "%s%s", dec_str, fp_suffix); | |
623 | sprintf (buf2, fp_cast, buf1); | |
624 | sprintf (buf1, "%s=%s", macro, buf2); | |
625 | ||
626 | cpp_define (parse_in, buf1); | |
cb60f38d NB |
627 | } |
628 | ||
629 | /* Define MAX for TYPE based on the precision of the type. IS_LONG is | |
630 | 1 for type "long" and 2 for "long long". We have to handle | |
631 | unsigned types, since wchar_t might be unsigned. */ | |
632 | ||
633 | static void | |
35b1a6fa | 634 | builtin_define_type_max (const char *macro, tree type, int is_long) |
cb60f38d NB |
635 | { |
636 | static const char *const values[] | |
637 | = { "127", "255", | |
638 | "32767", "65535", | |
639 | "2147483647", "4294967295", | |
640 | "9223372036854775807", "18446744073709551615", | |
641 | "170141183460469231731687303715884105727", | |
642 | "340282366920938463463374607431768211455" }; | |
643 | static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" }; | |
644 | ||
645 | const char *value, *suffix; | |
646 | char *buf; | |
647 | size_t idx; | |
648 | ||
649 | /* Pre-rendering the values mean we don't have to futz with printing a | |
650 | multi-word decimal value. There are also a very limited number of | |
651 | precisions that we support, so it's really a waste of time. */ | |
652 | switch (TYPE_PRECISION (type)) | |
653 | { | |
654 | case 8: idx = 0; break; | |
655 | case 16: idx = 2; break; | |
656 | case 32: idx = 4; break; | |
657 | case 64: idx = 6; break; | |
658 | case 128: idx = 8; break; | |
366de0ce | 659 | default: gcc_unreachable (); |
cb60f38d NB |
660 | } |
661 | ||
8df83eae RK |
662 | value = values[idx + TYPE_UNSIGNED (type)]; |
663 | suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)]; | |
cb60f38d NB |
664 | |
665 | buf = alloca (strlen (macro) + 1 + strlen (value) + strlen (suffix) + 1); | |
666 | sprintf (buf, "%s=%s%s", macro, value, suffix); | |
667 | ||
668 | cpp_define (parse_in, buf); | |
669 | } |