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