1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002-2018 Free Software Foundation, Inc.
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 3, 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 COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "target.h"
24 #include "c-common.h"
25 #include "memmodel.h"
26 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
27 #include "stringpool.h"
28 #include "stor-layout.h"
29 #include "flags.h"
30 #include "c-pragma.h"
31 #include "output.h" /* For user_label_prefix. */
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
33 #include "common/common-target.h"
34 #include "cpp-id-data.h"
35 #include "cppbuiltin.h"
36
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
45 #ifndef REGISTER_PREFIX
46 #define REGISTER_PREFIX ""
47 #endif
48
49 /* Non-static as some targets don't use it. */
50 static void builtin_define_with_hex_fp_value (const char *, tree,
51 int, const char *,
52 const char *,
53 const char *);
54 static void builtin_define_stdint_macros (void);
55 static void builtin_define_constants (const char *, tree);
56 static void builtin_define_type_max (const char *, tree);
57 static void builtin_define_type_minmax (const char *, const char *, tree);
58 static void builtin_define_type_width (const char *, tree, tree);
59 static void builtin_define_float_constants (const char *,
60 const char *,
61 const char *,
62 const char *,
63 tree);
64
65 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
66 Originally this function used the fma optab, but that doesn't work with
67 -save-temps, so just rely on the HAVE_fma macros for the standard floating
68 point types. */
69
70 static bool
mode_has_fma(machine_mode mode)71 mode_has_fma (machine_mode mode)
72 {
73 switch (mode)
74 {
75 #ifdef HAVE_fmasf4
76 case E_SFmode:
77 return !!HAVE_fmasf4;
78 #endif
79
80 #ifdef HAVE_fmadf4
81 case E_DFmode:
82 return !!HAVE_fmadf4;
83 #endif
84
85 #ifdef HAVE_fmakf4 /* PowerPC if long double != __float128. */
86 case E_KFmode:
87 return !!HAVE_fmakf4;
88 #endif
89
90 #ifdef HAVE_fmaxf4
91 case E_XFmode:
92 return !!HAVE_fmaxf4;
93 #endif
94
95 #ifdef HAVE_fmatf4
96 case E_TFmode:
97 return !!HAVE_fmatf4;
98 #endif
99
100 default:
101 break;
102 }
103
104 return false;
105 }
106
107 /* Define NAME with value TYPE size_unit. */
108 void
builtin_define_type_sizeof(const char * name,tree type)109 builtin_define_type_sizeof (const char *name, tree type)
110 {
111 builtin_define_with_int_value (name,
112 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
113 }
114
115 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
116 and FP_CAST. */
117 static void
builtin_define_float_constants(const char * name_prefix,const char * fp_suffix,const char * fp_cast,const char * fma_suffix,tree type)118 builtin_define_float_constants (const char *name_prefix,
119 const char *fp_suffix,
120 const char *fp_cast,
121 const char *fma_suffix,
122 tree type)
123 {
124 /* Used to convert radix-based values to base 10 values in several cases.
125
126 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
127 least 6 significant digits for correct results. Using the fraction
128 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
129 intermediate; perhaps someone can find a better approximation, in the
130 mean time, I suspect using doubles won't harm the bootstrap here. */
131
132 const double log10_2 = .30102999566398119521;
133 double log10_b;
134 const struct real_format *fmt;
135 const struct real_format *widefmt;
136
137 char name[64], buf[128];
138 int dig, min_10_exp, max_10_exp;
139 int decimal_dig;
140 int type_decimal_dig;
141
142 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
143 gcc_assert (fmt->b != 10);
144 widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
145 gcc_assert (widefmt->b != 10);
146 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
147 {
148 tree wtype = FLOATN_NX_TYPE_NODE (i);
149 if (wtype != NULL_TREE)
150 {
151 const struct real_format *wfmt
152 = REAL_MODE_FORMAT (TYPE_MODE (wtype));
153 gcc_assert (wfmt->b != 10);
154 if (wfmt->p > widefmt->p)
155 widefmt = wfmt;
156 }
157 }
158
159 /* The radix of the exponent representation. */
160 if (type == float_type_node)
161 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
162 log10_b = log10_2;
163
164 /* The number of radix digits, p, in the floating-point significand. */
165 sprintf (name, "__%s_MANT_DIG__", name_prefix);
166 builtin_define_with_int_value (name, fmt->p);
167
168 /* The number of decimal digits, q, such that any floating-point number
169 with q decimal digits can be rounded into a floating-point number with
170 p radix b digits and back again without change to the q decimal digits,
171
172 p log10 b if b is a power of 10
173 floor((p - 1) log10 b) otherwise
174 */
175 dig = (fmt->p - 1) * log10_b;
176 sprintf (name, "__%s_DIG__", name_prefix);
177 builtin_define_with_int_value (name, dig);
178
179 /* The minimum negative int x such that b**(x-1) is a normalized float. */
180 sprintf (name, "__%s_MIN_EXP__", name_prefix);
181 sprintf (buf, "(%d)", fmt->emin);
182 builtin_define_with_value (name, buf, 0);
183
184 /* The minimum negative int x such that 10**x is a normalized float,
185
186 ceil (log10 (b ** (emin - 1)))
187 = ceil (log10 (b) * (emin - 1))
188
189 Recall that emin is negative, so the integer truncation calculates
190 the ceiling, not the floor, in this case. */
191 min_10_exp = (fmt->emin - 1) * log10_b;
192 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
193 sprintf (buf, "(%d)", min_10_exp);
194 builtin_define_with_value (name, buf, 0);
195
196 /* The maximum int x such that b**(x-1) is a representable float. */
197 sprintf (name, "__%s_MAX_EXP__", name_prefix);
198 builtin_define_with_int_value (name, fmt->emax);
199
200 /* The maximum int x such that 10**x is in the range of representable
201 finite floating-point numbers,
202
203 floor (log10((1 - b**-p) * b**emax))
204 = floor (log10(1 - b**-p) + log10(b**emax))
205 = floor (log10(1 - b**-p) + log10(b)*emax)
206
207 The safest thing to do here is to just compute this number. But since
208 we don't link cc1 with libm, we cannot. We could implement log10 here
209 a series expansion, but that seems too much effort because:
210
211 Note that the first term, for all extant p, is a number exceedingly close
212 to zero, but slightly negative. Note that the second term is an integer
213 scaling an irrational number, and that because of the floor we are only
214 interested in its integral portion.
215
216 In order for the first term to have any effect on the integral portion
217 of the second term, the second term has to be exceedingly close to an
218 integer itself (e.g. 123.000000000001 or something). Getting a result
219 that close to an integer requires that the irrational multiplicand have
220 a long series of zeros in its expansion, which doesn't occur in the
221 first 20 digits or so of log10(b).
222
223 Hand-waving aside, crunching all of the sets of constants above by hand
224 does not yield a case for which the first term is significant, which
225 in the end is all that matters. */
226 max_10_exp = fmt->emax * log10_b;
227 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
228 builtin_define_with_int_value (name, max_10_exp);
229
230 /* The number of decimal digits, n, such that any floating-point number
231 can be rounded to n decimal digits and back again without change to
232 the value.
233
234 p * log10(b) if b is a power of 10
235 ceil(1 + p * log10(b)) otherwise
236
237 The only macro we care about is this number for the widest supported
238 floating type, but we want this value for rendering constants below. */
239 {
240 double d_decimal_dig
241 = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
242 decimal_dig = d_decimal_dig;
243 if (decimal_dig < d_decimal_dig)
244 decimal_dig++;
245 }
246 /* Similar, for this type rather than long double. */
247 {
248 double type_d_decimal_dig = 1 + fmt->p * log10_b;
249 type_decimal_dig = type_d_decimal_dig;
250 if (type_decimal_dig < type_d_decimal_dig)
251 type_decimal_dig++;
252 }
253 /* Define __DECIMAL_DIG__ to the value for long double to be
254 compatible with C99 and C11; see DR#501 and N2108. */
255 if (type == long_double_type_node)
256 builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig);
257 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
258 builtin_define_with_int_value (name, type_decimal_dig);
259
260 /* Since, for the supported formats, B is always a power of 2, we
261 construct the following numbers directly as a hexadecimal
262 constants. */
263 get_max_float (fmt, buf, sizeof (buf));
264
265 sprintf (name, "__%s_MAX__", name_prefix);
266 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
267
268 /* The minimum normalized positive floating-point number,
269 b**(emin-1). */
270 sprintf (name, "__%s_MIN__", name_prefix);
271 sprintf (buf, "0x1p%d", fmt->emin - 1);
272 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
273
274 /* The difference between 1 and the least value greater than 1 that is
275 representable in the given floating point type, b**(1-p). */
276 sprintf (name, "__%s_EPSILON__", name_prefix);
277 if (fmt->pnan < fmt->p)
278 /* This is an IBM extended double format, so 1.0 + any double is
279 representable precisely. */
280 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
281 else
282 sprintf (buf, "0x1p%d", 1 - fmt->p);
283 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
284
285 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
286 The minimum denormalized positive floating-point number, b**(emin-p).
287 The minimum normalized positive floating-point number for formats
288 that don't support denormals. */
289 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
290 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
291 builtin_define_with_hex_fp_value (name, type, decimal_dig,
292 buf, fp_suffix, fp_cast);
293
294 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
295 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
296
297 /* For C++ std::numeric_limits<T>::has_infinity. */
298 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
299 builtin_define_with_int_value (name,
300 MODE_HAS_INFINITIES (TYPE_MODE (type)));
301 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
302 predicate to distinguish a target that has both quiet and
303 signalling NaNs from a target that has only quiet NaNs or only
304 signalling NaNs, so we assume that a target that has any kind of
305 NaN has quiet NaNs. */
306 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
307 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
308
309 /* Note whether we have fast FMA. */
310 if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
311 {
312 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
313 builtin_define_with_int_value (name, 1);
314 }
315 }
316
317 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
318 static void
builtin_define_decimal_float_constants(const char * name_prefix,const char * suffix,tree type)319 builtin_define_decimal_float_constants (const char *name_prefix,
320 const char *suffix,
321 tree type)
322 {
323 const struct real_format *fmt;
324 char name[64], buf[128], *p;
325 int digits;
326
327 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
328
329 /* The number of radix digits, p, in the significand. */
330 sprintf (name, "__%s_MANT_DIG__", name_prefix);
331 builtin_define_with_int_value (name, fmt->p);
332
333 /* The minimum negative int x such that b**(x-1) is a normalized float. */
334 sprintf (name, "__%s_MIN_EXP__", name_prefix);
335 sprintf (buf, "(%d)", fmt->emin);
336 builtin_define_with_value (name, buf, 0);
337
338 /* The maximum int x such that b**(x-1) is a representable float. */
339 sprintf (name, "__%s_MAX_EXP__", name_prefix);
340 builtin_define_with_int_value (name, fmt->emax);
341
342 /* Compute the minimum representable value. */
343 sprintf (name, "__%s_MIN__", name_prefix);
344 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
345 builtin_define_with_value (name, buf, 0);
346
347 /* Compute the maximum representable value. */
348 sprintf (name, "__%s_MAX__", name_prefix);
349 p = buf;
350 for (digits = fmt->p; digits; digits--)
351 {
352 *p++ = '9';
353 if (digits == fmt->p)
354 *p++ = '.';
355 }
356 *p = 0;
357 /* fmt->p plus 1, to account for the decimal point and fmt->emax
358 minus 1 because the digits are nines, not 1.0. */
359 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
360 builtin_define_with_value (name, buf, 0);
361
362 /* Compute epsilon (the difference between 1 and least value greater
363 than 1 representable). */
364 sprintf (name, "__%s_EPSILON__", name_prefix);
365 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
366 builtin_define_with_value (name, buf, 0);
367
368 /* Minimum subnormal positive decimal value. */
369 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
370 p = buf;
371 for (digits = fmt->p; digits > 1; digits--)
372 {
373 *p++ = '0';
374 if (digits == fmt->p)
375 *p++ = '.';
376 }
377 *p = 0;
378 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
379 builtin_define_with_value (name, buf, 0);
380 }
381
382 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
383
384 static void
builtin_define_fixed_point_constants(const char * name_prefix,const char * suffix,tree type)385 builtin_define_fixed_point_constants (const char *name_prefix,
386 const char *suffix,
387 tree type)
388 {
389 char name[64], buf[256], *new_buf;
390 int i, mod;
391
392 sprintf (name, "__%s_FBIT__", name_prefix);
393 builtin_define_with_int_value (name, TYPE_FBIT (type));
394
395 sprintf (name, "__%s_IBIT__", name_prefix);
396 builtin_define_with_int_value (name, TYPE_IBIT (type));
397
398 /* If there is no suffix, defines are for fixed-point modes.
399 We just return. */
400 if (strcmp (suffix, "") == 0)
401 return;
402
403 if (TYPE_UNSIGNED (type))
404 {
405 sprintf (name, "__%s_MIN__", name_prefix);
406 sprintf (buf, "0.0%s", suffix);
407 builtin_define_with_value (name, buf, 0);
408 }
409 else
410 {
411 sprintf (name, "__%s_MIN__", name_prefix);
412 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
413 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
414 TYPE_IBIT (type) - 1, suffix);
415 else
416 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
417 builtin_define_with_value (name, buf, 0);
418 }
419
420 sprintf (name, "__%s_MAX__", name_prefix);
421 sprintf (buf, "0X");
422 new_buf = buf + 2;
423 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
424 if (mod)
425 sprintf (new_buf++, "%x", (1 << mod) - 1);
426 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
427 sprintf (new_buf++, "F");
428 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
429 builtin_define_with_value (name, buf, 0);
430
431 sprintf (name, "__%s_EPSILON__", name_prefix);
432 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
433 builtin_define_with_value (name, buf, 0);
434 }
435
436 /* Define macros used by <stdint.h>. */
437 static void
builtin_define_stdint_macros(void)438 builtin_define_stdint_macros (void)
439 {
440 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
441 builtin_define_constants ("__INTMAX_C", intmax_type_node);
442 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
443 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
444 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
445 uintmax_type_node);
446 if (sig_atomic_type_node)
447 {
448 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
449 sig_atomic_type_node);
450 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
451 NULL_TREE);
452 }
453 if (int8_type_node)
454 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
455 if (int16_type_node)
456 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
457 if (int32_type_node)
458 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
459 if (int64_type_node)
460 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
461 if (uint8_type_node)
462 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
463 if (c_uint16_type_node)
464 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
465 if (c_uint32_type_node)
466 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
467 if (c_uint64_type_node)
468 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
469 if (int_least8_type_node)
470 {
471 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
472 builtin_define_constants ("__INT8_C", int_least8_type_node);
473 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
474 uint_least8_type_node);
475 }
476 if (int_least16_type_node)
477 {
478 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
479 builtin_define_constants ("__INT16_C", int_least16_type_node);
480 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
481 int_least16_type_node,
482 uint_least16_type_node);
483 }
484 if (int_least32_type_node)
485 {
486 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
487 builtin_define_constants ("__INT32_C", int_least32_type_node);
488 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
489 int_least32_type_node,
490 uint_least32_type_node);
491 }
492 if (int_least64_type_node)
493 {
494 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
495 builtin_define_constants ("__INT64_C", int_least64_type_node);
496 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
497 int_least64_type_node,
498 uint_least64_type_node);
499 }
500 if (uint_least8_type_node)
501 {
502 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
503 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
504 }
505 if (uint_least16_type_node)
506 {
507 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
508 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
509 }
510 if (uint_least32_type_node)
511 {
512 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
513 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
514 }
515 if (uint_least64_type_node)
516 {
517 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
518 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
519 }
520 if (int_fast8_type_node)
521 {
522 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
523 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node,
524 uint_fast8_type_node);
525 }
526 if (int_fast16_type_node)
527 {
528 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
529 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node,
530 uint_fast16_type_node);
531 }
532 if (int_fast32_type_node)
533 {
534 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
535 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node,
536 uint_fast32_type_node);
537 }
538 if (int_fast64_type_node)
539 {
540 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
541 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
542 uint_fast64_type_node);
543 }
544 if (uint_fast8_type_node)
545 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
546 if (uint_fast16_type_node)
547 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
548 if (uint_fast32_type_node)
549 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
550 if (uint_fast64_type_node)
551 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
552 if (intptr_type_node)
553 {
554 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
555 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
556 uintptr_type_node);
557 }
558 if (uintptr_type_node)
559 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
560 }
561
562 /* Adjust the optimization macros when a #pragma GCC optimization is done to
563 reflect the current level. */
564 void
c_cpp_builtins_optimize_pragma(cpp_reader * pfile,tree prev_tree,tree cur_tree)565 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
566 tree cur_tree)
567 {
568 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
569 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
570 bool prev_fast_math;
571 bool cur_fast_math;
572
573 /* -undef turns off target-specific built-ins. */
574 if (flag_undef)
575 return;
576
577 /* Other target-independent built-ins determined by command-line
578 options. */
579 if (!prev->x_optimize_size && cur->x_optimize_size)
580 cpp_define (pfile, "__OPTIMIZE_SIZE__");
581 else if (prev->x_optimize_size && !cur->x_optimize_size)
582 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
583
584 if (!prev->x_optimize && cur->x_optimize)
585 cpp_define (pfile, "__OPTIMIZE__");
586 else if (prev->x_optimize && !cur->x_optimize)
587 cpp_undef (pfile, "__OPTIMIZE__");
588
589 prev_fast_math = fast_math_flags_struct_set_p (prev);
590 cur_fast_math = fast_math_flags_struct_set_p (cur);
591 if (!prev_fast_math && cur_fast_math)
592 cpp_define (pfile, "__FAST_MATH__");
593 else if (prev_fast_math && !cur_fast_math)
594 cpp_undef (pfile, "__FAST_MATH__");
595
596 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
597 cpp_define (pfile, "__SUPPORT_SNAN__");
598 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
599 cpp_undef (pfile, "__SUPPORT_SNAN__");
600
601 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
602 cpp_undef (pfile, "__NO_MATH_ERRNO__");
603 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
604 cpp_define (pfile, "__NO_MATH_ERRNO__");
605
606 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
607 {
608 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
609 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
610 }
611 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
612 {
613 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
614 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
615 }
616 }
617
618
619 /* This function will emit cpp macros to indicate the presence of various lock
620 free atomic operations. */
621
622 static void
cpp_atomic_builtins(cpp_reader * pfile)623 cpp_atomic_builtins (cpp_reader *pfile)
624 {
625 /* Set a flag for each size of object that compare and swap exists for up to
626 a 16 byte object. */
627 #define SWAP_LIMIT 17
628 bool have_swap[SWAP_LIMIT];
629 unsigned int psize;
630
631 /* Clear the map of sizes compare_and swap exists for. */
632 memset (have_swap, 0, sizeof (have_swap));
633
634 /* Tell source code if the compiler makes sync_compare_and_swap
635 builtins available. */
636 #ifndef HAVE_sync_compare_and_swapqi
637 #define HAVE_sync_compare_and_swapqi 0
638 #endif
639 #ifndef HAVE_atomic_compare_and_swapqi
640 #define HAVE_atomic_compare_and_swapqi 0
641 #endif
642
643 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
644 {
645 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
646 have_swap[1] = true;
647 }
648
649 #ifndef HAVE_sync_compare_and_swaphi
650 #define HAVE_sync_compare_and_swaphi 0
651 #endif
652 #ifndef HAVE_atomic_compare_and_swaphi
653 #define HAVE_atomic_compare_and_swaphi 0
654 #endif
655 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
656 {
657 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
658 have_swap[2] = true;
659 }
660
661 #ifndef HAVE_sync_compare_and_swapsi
662 #define HAVE_sync_compare_and_swapsi 0
663 #endif
664 #ifndef HAVE_atomic_compare_and_swapsi
665 #define HAVE_atomic_compare_and_swapsi 0
666 #endif
667 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
668 {
669 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
670 have_swap[4] = true;
671 }
672
673 #ifndef HAVE_sync_compare_and_swapdi
674 #define HAVE_sync_compare_and_swapdi 0
675 #endif
676 #ifndef HAVE_atomic_compare_and_swapdi
677 #define HAVE_atomic_compare_and_swapdi 0
678 #endif
679 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
680 {
681 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
682 have_swap[8] = true;
683 }
684
685 #ifndef HAVE_sync_compare_and_swapti
686 #define HAVE_sync_compare_and_swapti 0
687 #endif
688 #ifndef HAVE_atomic_compare_and_swapti
689 #define HAVE_atomic_compare_and_swapti 0
690 #endif
691 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
692 {
693 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
694 have_swap[16] = true;
695 }
696
697 /* Tell the source code about various types. These map to the C++11 and C11
698 macros where 2 indicates lock-free always, and 1 indicates sometimes
699 lock free. */
700 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
701 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
702 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
703 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
704 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
705 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
706 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
707 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
708 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
709 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
710 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
711 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
712 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
713 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
714 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
715 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
716 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
717 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
718 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
719 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
720
721 /* If we're dealing with a "set" value that doesn't exactly correspond
722 to a boolean truth value, let the library work around that. */
723 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
724 targetm.atomic_test_and_set_trueval);
725
726 /* ptr_type_node can't be used here since ptr_mode is only set when
727 toplev calls backend_init which is not done with -E or pch. */
728 psize = POINTER_SIZE_UNITS;
729 if (psize >= SWAP_LIMIT)
730 psize = 0;
731 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
732 (have_swap[psize]? 2 : 1));
733 }
734
735 /* Return TRUE if the implicit excess precision in which the back-end will
736 compute floating-point calculations is not more than the explicit
737 excess precision that the front-end will apply under
738 -fexcess-precision=[standard|fast].
739
740 More intuitively, return TRUE if the excess precision proposed by the
741 front-end is the excess precision that will actually be used. */
742
743 static bool
c_cpp_flt_eval_method_iec_559(void)744 c_cpp_flt_eval_method_iec_559 (void)
745 {
746 enum excess_precision_type front_end_ept
747 = (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
748 ? EXCESS_PRECISION_TYPE_STANDARD
749 : EXCESS_PRECISION_TYPE_FAST);
750
751 enum flt_eval_method back_end
752 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
753
754 enum flt_eval_method front_end
755 = targetm.c.excess_precision (front_end_ept);
756
757 return excess_precision_mode_join (front_end, back_end) == front_end;
758 }
759
760 /* Return the value for __GCC_IEC_559. */
761 static int
cpp_iec_559_value(void)762 cpp_iec_559_value (void)
763 {
764 /* The default is support for IEEE 754-2008. */
765 int ret = 2;
766
767 /* float and double must be binary32 and binary64. If they are but
768 with reversed NaN convention, at most IEEE 754-1985 is
769 supported. */
770 const struct real_format *ffmt
771 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
772 const struct real_format *dfmt
773 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
774 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
775 ret = 1;
776 if (ffmt->b != 2
777 || ffmt->p != 24
778 || ffmt->pnan != 24
779 || ffmt->emin != -125
780 || ffmt->emax != 128
781 || ffmt->signbit_rw != 31
782 || ffmt->round_towards_zero
783 || !ffmt->has_sign_dependent_rounding
784 || !ffmt->has_nans
785 || !ffmt->has_inf
786 || !ffmt->has_denorm
787 || !ffmt->has_signed_zero
788 || dfmt->b != 2
789 || dfmt->p != 53
790 || dfmt->pnan != 53
791 || dfmt->emin != -1021
792 || dfmt->emax != 1024
793 || dfmt->signbit_rw != 63
794 || dfmt->round_towards_zero
795 || !dfmt->has_sign_dependent_rounding
796 || !dfmt->has_nans
797 || !dfmt->has_inf
798 || !dfmt->has_denorm
799 || !dfmt->has_signed_zero)
800 ret = 0;
801
802 /* In strict C standards conformance mode, consider a back-end providing
803 more implicit excess precision than the explicit excess precision
804 the front-end options would require to mean a lack of IEEE 754
805 support. For C++, and outside strict conformance mode, do not consider
806 this to mean a lack of IEEE 754 support. */
807
808 if (flag_iso
809 && !c_dialect_cxx ()
810 && !c_cpp_flt_eval_method_iec_559 ())
811 ret = 0;
812
813 if (flag_iso
814 && !c_dialect_cxx ()
815 && flag_fp_contract_mode == FP_CONTRACT_FAST)
816 ret = 0;
817
818 /* Various options are contrary to IEEE 754 semantics. */
819 if (flag_unsafe_math_optimizations
820 || flag_associative_math
821 || flag_reciprocal_math
822 || flag_finite_math_only
823 || !flag_signed_zeros
824 || flag_single_precision_constant)
825 ret = 0;
826
827 /* If the target does not support IEEE 754 exceptions and rounding
828 modes, consider IEEE 754 support to be absent. */
829 if (!targetm.float_exceptions_rounding_supported_p ())
830 ret = 0;
831
832 return ret;
833 }
834
835 /* Return the value for __GCC_IEC_559_COMPLEX. */
836 static int
cpp_iec_559_complex_value(void)837 cpp_iec_559_complex_value (void)
838 {
839 /* The value is no bigger than that of __GCC_IEC_559. */
840 int ret = cpp_iec_559_value ();
841
842 /* Some options are contrary to the required default state of the
843 CX_LIMITED_RANGE pragma. */
844 if (flag_complex_method != 2)
845 ret = 0;
846
847 return ret;
848 }
849
850 /* Hook that registers front end and target-specific built-ins. */
851 void
c_cpp_builtins(cpp_reader * pfile)852 c_cpp_builtins (cpp_reader *pfile)
853 {
854 int i;
855
856 /* -undef turns off target-specific built-ins. */
857 if (flag_undef)
858 return;
859
860 define_language_independent_builtin_macros (pfile);
861
862 if (c_dialect_cxx ())
863 {
864 int major;
865 parse_basever (&major, NULL, NULL);
866 cpp_define_formatted (pfile, "__GNUG__=%d", major);
867 }
868
869 /* For stddef.h. They require macros defined in c-common.c. */
870 c_stddef_cpp_builtins ();
871
872 /* Set include test macros for all C/C++ (not for just C++11 etc.)
873 The builtins __has_include__ and __has_include_next__ are defined
874 in libcpp. */
875 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
876 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
877
878 if (c_dialect_cxx ())
879 {
880 if (flag_weak && SUPPORTS_ONE_ONLY)
881 cpp_define (pfile, "__GXX_WEAK__=1");
882 else
883 cpp_define (pfile, "__GXX_WEAK__=0");
884
885 if (warn_deprecated)
886 cpp_define (pfile, "__DEPRECATED");
887
888 if (flag_rtti)
889 {
890 cpp_define (pfile, "__GXX_RTTI");
891 cpp_define (pfile, "__cpp_rtti=199711");
892 }
893
894 if (cxx_dialect >= cxx11)
895 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
896
897 /* Binary literals have been allowed in g++ before C++11
898 and were standardized for C++14. */
899 if (!pedantic || cxx_dialect > cxx11)
900 cpp_define (pfile, "__cpp_binary_literals=201304");
901
902 /* Similarly for hexadecimal floating point literals and C++17. */
903 if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
904 cpp_define (pfile, "__cpp_hex_float=201603");
905
906 /* Arrays of runtime bound were removed from C++14, but we still
907 support GNU VLAs. Let's define this macro to a low number
908 (corresponding to the initial test release of GNU C++) if we won't
909 complain about use of VLAs. */
910 if (c_dialect_cxx ()
911 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
912 cpp_define (pfile, "__cpp_runtime_arrays=198712");
913
914 if (cxx_dialect >= cxx11)
915 {
916 /* Set feature test macros for C++11. */
917 if (cxx_dialect <= cxx14)
918 cpp_define (pfile, "__cpp_unicode_characters=200704");
919 cpp_define (pfile, "__cpp_raw_strings=200710");
920 cpp_define (pfile, "__cpp_unicode_literals=200710");
921 cpp_define (pfile, "__cpp_user_defined_literals=200809");
922 cpp_define (pfile, "__cpp_lambdas=200907");
923 if (cxx_dialect == cxx11)
924 cpp_define (pfile, "__cpp_constexpr=200704");
925 if (cxx_dialect <= cxx14)
926 cpp_define (pfile, "__cpp_range_based_for=200907");
927 if (cxx_dialect <= cxx14)
928 cpp_define (pfile, "__cpp_static_assert=200410");
929 cpp_define (pfile, "__cpp_decltype=200707");
930 cpp_define (pfile, "__cpp_attributes=200809");
931 cpp_define (pfile, "__cpp_rvalue_reference=200610");
932 cpp_define (pfile, "__cpp_rvalue_references=200610");
933 cpp_define (pfile, "__cpp_variadic_templates=200704");
934 cpp_define (pfile, "__cpp_initializer_lists=200806");
935 cpp_define (pfile, "__cpp_delegating_constructors=200604");
936 cpp_define (pfile, "__cpp_nsdmi=200809");
937 if (!flag_new_inheriting_ctors)
938 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
939 else
940 cpp_define (pfile, "__cpp_inheriting_constructors=201511");
941 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
942 cpp_define (pfile, "__cpp_alias_templates=200704");
943 }
944 if (cxx_dialect > cxx11)
945 {
946 /* Set feature test macros for C++14. */
947 cpp_define (pfile, "__cpp_return_type_deduction=201304");
948 cpp_define (pfile, "__cpp_init_captures=201304");
949 cpp_define (pfile, "__cpp_generic_lambdas=201304");
950 if (cxx_dialect <= cxx14)
951 cpp_define (pfile, "__cpp_constexpr=201304");
952 cpp_define (pfile, "__cpp_decltype_auto=201304");
953 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
954 cpp_define (pfile, "__cpp_variable_templates=201304");
955 cpp_define (pfile, "__cpp_digit_separators=201309");
956 }
957 if (cxx_dialect > cxx14)
958 {
959 /* Set feature test macros for C++1z. */
960 cpp_define (pfile, "__cpp_unicode_characters=201411");
961 cpp_define (pfile, "__cpp_static_assert=201411");
962 cpp_define (pfile, "__cpp_namespace_attributes=201411");
963 cpp_define (pfile, "__cpp_enumerator_attributes=201411");
964 cpp_define (pfile, "__cpp_nested_namespace_definitions=201411");
965 cpp_define (pfile, "__cpp_fold_expressions=201603");
966 cpp_define (pfile, "__cpp_nontype_template_args=201411");
967 cpp_define (pfile, "__cpp_range_based_for=201603");
968 cpp_define (pfile, "__cpp_constexpr=201603");
969 cpp_define (pfile, "__cpp_if_constexpr=201606");
970 cpp_define (pfile, "__cpp_capture_star_this=201603");
971 cpp_define (pfile, "__cpp_inline_variables=201606");
972 cpp_define (pfile, "__cpp_aggregate_bases=201603");
973 cpp_define (pfile, "__cpp_deduction_guides=201611");
974 cpp_define (pfile, "__cpp_noexcept_function_type=201510");
975 /* Old macro, superseded by
976 __cpp_nontype_template_parameter_auto. */
977 cpp_define (pfile, "__cpp_template_auto=201606");
978 cpp_define (pfile, "__cpp_structured_bindings=201606");
979 cpp_define (pfile, "__cpp_variadic_using=201611");
980 cpp_define (pfile, "__cpp_guaranteed_copy_elision=201606");
981 cpp_define (pfile, "__cpp_nontype_template_parameter_auto=201606");
982 }
983 if (flag_concepts)
984 cpp_define (pfile, "__cpp_concepts=201507");
985 if (flag_tm)
986 /* Use a value smaller than the 201505 specified in
987 the TS, since we don't yet support atomic_cancel. */
988 cpp_define (pfile, "__cpp_transactional_memory=210500");
989 if (flag_sized_deallocation)
990 cpp_define (pfile, "__cpp_sized_deallocation=201309");
991 if (aligned_new_threshold)
992 {
993 cpp_define (pfile, "__cpp_aligned_new=201606");
994 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
995 aligned_new_threshold);
996 }
997 if (flag_new_ttp)
998 cpp_define (pfile, "__cpp_template_template_args=201611");
999 if (flag_threadsafe_statics)
1000 cpp_define (pfile, "__cpp_threadsafe_static_init=200806");
1001 }
1002 /* Note that we define this for C as well, so that we know if
1003 __attribute__((cleanup)) will interface with EH. */
1004 if (flag_exceptions)
1005 {
1006 cpp_define (pfile, "__EXCEPTIONS");
1007 if (c_dialect_cxx ())
1008 cpp_define (pfile, "__cpp_exceptions=199711");
1009 }
1010
1011 /* Represents the C++ ABI version, always defined so it can be used while
1012 preprocessing C and assembler. */
1013 if (flag_abi_version == 0)
1014 /* We should have set this to something real in c_common_post_options. */
1015 gcc_unreachable ();
1016 else if (flag_abi_version == 1)
1017 /* Due to a historical accident, this version had the value
1018 "102". */
1019 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
1020 else
1021 /* Newer versions have values 1002, 1003, .... */
1022 builtin_define_with_int_value ("__GXX_ABI_VERSION",
1023 1000 + flag_abi_version);
1024
1025 /* libgcc needs to know this. */
1026 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
1027 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
1028
1029 /* limits.h and stdint.h need to know these. */
1030 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
1031 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
1032 builtin_define_type_max ("__INT_MAX__", integer_type_node);
1033 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
1034 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
1035 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
1036 underlying_wchar_type_node);
1037 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
1038 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
1039 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
1040
1041 /* These are needed for TS 18661-1. */
1042 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
1043 unsigned_char_type_node);
1044 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
1045 short_unsigned_type_node);
1046 builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
1047 unsigned_type_node);
1048 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
1049 long_unsigned_type_node);
1050 builtin_define_type_width ("__LONG_LONG_WIDTH__",
1051 long_long_integer_type_node,
1052 long_long_unsigned_type_node);
1053 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
1054 NULL_TREE);
1055 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
1056 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
1057 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
1058
1059 if (c_dialect_cxx ())
1060 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1061 if (int_n_enabled_p[i])
1062 {
1063 char buf[35+20+20];
1064
1065 /* These are used to configure the C++ library. */
1066
1067 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
1068 {
1069 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
1070 cpp_define (parse_in, buf);
1071
1072 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
1073 cpp_define (parse_in, buf);
1074 }
1075 }
1076
1077 /* stdint.h and the testsuite need to know these. */
1078 builtin_define_stdint_macros ();
1079
1080 /* Provide information for library headers to determine whether to
1081 define macros such as __STDC_IEC_559__ and
1082 __STDC_IEC_559_COMPLEX__. */
1083 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
1084 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
1085 cpp_iec_559_complex_value ());
1086
1087 /* float.h needs these to correctly set FLT_EVAL_METHOD
1088
1089 We define two values:
1090
1091 __FLT_EVAL_METHOD__
1092 Which, depending on the value given for
1093 -fpermitted-flt-eval-methods, may be limited to only those values
1094 for FLT_EVAL_METHOD defined in C99/C11.
1095
1096 __FLT_EVAL_METHOD_TS_18661_3__
1097 Which always permits the values for FLT_EVAL_METHOD defined in
1098 ISO/IEC TS 18661-3. */
1099 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
1100 c_flt_eval_method (true));
1101 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
1102 c_flt_eval_method (false));
1103
1104 /* And decfloat.h needs this. */
1105 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
1106 TARGET_DEC_EVAL_METHOD);
1107
1108 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
1109 /* Cast the double precision constants. This is needed when single
1110 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
1111 is used. The correct result is computed by the compiler when using
1112 macros that include a cast. We use a different cast for C++ to avoid
1113 problems with -Wold-style-cast. */
1114 builtin_define_float_constants ("DBL", "L",
1115 (c_dialect_cxx ()
1116 ? "double(%s)"
1117 : "((double)%s)"),
1118 "", double_type_node);
1119 builtin_define_float_constants ("LDBL", "L", "%s", "L",
1120 long_double_type_node);
1121
1122 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1123 {
1124 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
1125 continue;
1126 char prefix[20], csuffix[20];
1127 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
1128 floatn_nx_types[i].extended ? "X" : "");
1129 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
1130 floatn_nx_types[i].extended ? "x" : "");
1131 builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s",
1132 csuffix, FLOATN_NX_TYPE_NODE (i));
1133 }
1134
1135 /* For decfloat.h. */
1136 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
1137 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
1138 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
1139
1140 /* For fixed-point fibt, ibit, max, min, and epsilon. */
1141 if (targetm.fixed_point_supported_p ())
1142 {
1143 builtin_define_fixed_point_constants ("SFRACT", "HR",
1144 short_fract_type_node);
1145 builtin_define_fixed_point_constants ("USFRACT", "UHR",
1146 unsigned_short_fract_type_node);
1147 builtin_define_fixed_point_constants ("FRACT", "R",
1148 fract_type_node);
1149 builtin_define_fixed_point_constants ("UFRACT", "UR",
1150 unsigned_fract_type_node);
1151 builtin_define_fixed_point_constants ("LFRACT", "LR",
1152 long_fract_type_node);
1153 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
1154 unsigned_long_fract_type_node);
1155 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
1156 long_long_fract_type_node);
1157 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
1158 unsigned_long_long_fract_type_node);
1159 builtin_define_fixed_point_constants ("SACCUM", "HK",
1160 short_accum_type_node);
1161 builtin_define_fixed_point_constants ("USACCUM", "UHK",
1162 unsigned_short_accum_type_node);
1163 builtin_define_fixed_point_constants ("ACCUM", "K",
1164 accum_type_node);
1165 builtin_define_fixed_point_constants ("UACCUM", "UK",
1166 unsigned_accum_type_node);
1167 builtin_define_fixed_point_constants ("LACCUM", "LK",
1168 long_accum_type_node);
1169 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
1170 unsigned_long_accum_type_node);
1171 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
1172 long_long_accum_type_node);
1173 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
1174 unsigned_long_long_accum_type_node);
1175
1176 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
1177 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
1178 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
1179 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
1180 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
1181 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
1182 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
1183 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
1184 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
1185 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
1186 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
1187 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
1188 builtin_define_fixed_point_constants ("DA", "", da_type_node);
1189 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
1190 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
1191 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
1192 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
1193 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
1194 }
1195
1196 /* For libgcc-internal use only. */
1197 if (flag_building_libgcc)
1198 {
1199 /* Properties of floating-point modes for libgcc2.c. */
1200 opt_scalar_float_mode mode_iter;
1201 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
1202 {
1203 scalar_float_mode mode = mode_iter.require ();
1204 const char *name = GET_MODE_NAME (mode);
1205 char *macro_name
1206 = (char *) alloca (strlen (name)
1207 + sizeof ("__LIBGCC__MANT_DIG__"));
1208 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
1209 builtin_define_with_int_value (macro_name,
1210 REAL_MODE_FORMAT (mode)->p);
1211 if (!targetm.scalar_mode_supported_p (mode)
1212 || !targetm.libgcc_floating_mode_supported_p (mode))
1213 continue;
1214 macro_name = (char *) alloca (strlen (name)
1215 + sizeof ("__LIBGCC_HAS__MODE__"));
1216 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
1217 cpp_define (pfile, macro_name);
1218 macro_name = (char *) alloca (strlen (name)
1219 + sizeof ("__LIBGCC__FUNC_EXT__"));
1220 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
1221 char suffix[20] = "";
1222 if (mode == TYPE_MODE (double_type_node))
1223 ; /* Empty suffix correct. */
1224 else if (mode == TYPE_MODE (float_type_node))
1225 suffix[0] = 'f';
1226 else if (mode == TYPE_MODE (long_double_type_node))
1227 suffix[0] = 'l';
1228 else
1229 {
1230 bool found_suffix = false;
1231 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1232 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
1233 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
1234 {
1235 sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
1236 floatn_nx_types[i].extended ? "x" : "");
1237 found_suffix = true;
1238 break;
1239 }
1240 gcc_assert (found_suffix);
1241 }
1242 builtin_define_with_value (macro_name, suffix, 0);
1243
1244 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
1245 eliminating excess precision from results assigned to
1246 variables - meaning it should be about the implicit excess
1247 precision only. */
1248 bool excess_precision = false;
1249 machine_mode float16_type_mode = (float16_type_node
1250 ? TYPE_MODE (float16_type_node)
1251 : VOIDmode);
1252 switch (targetm.c.excess_precision
1253 (EXCESS_PRECISION_TYPE_IMPLICIT))
1254 {
1255 case FLT_EVAL_METHOD_UNPREDICTABLE:
1256 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
1257 excess_precision = (mode == float16_type_mode
1258 || mode == TYPE_MODE (float_type_node)
1259 || mode == TYPE_MODE (double_type_node));
1260 break;
1261
1262 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
1263 excess_precision = (mode == float16_type_mode
1264 || mode == TYPE_MODE (float_type_node));
1265 break;
1266 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
1267 excess_precision = mode == float16_type_mode;
1268 break;
1269 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
1270 excess_precision = false;
1271 break;
1272 default:
1273 gcc_unreachable ();
1274 }
1275 macro_name = (char *) alloca (strlen (name)
1276 + sizeof ("__LIBGCC__EXCESS_"
1277 "PRECISION__"));
1278 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
1279 builtin_define_with_int_value (macro_name, excess_precision);
1280 }
1281
1282 /* For libgcc crtstuff.c and libgcc2.c. */
1283 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
1284 EH_TABLES_CAN_BE_READ_ONLY);
1285 #ifdef EH_FRAME_SECTION_NAME
1286 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
1287 EH_FRAME_SECTION_NAME, 1);
1288 #endif
1289 #ifdef CTORS_SECTION_ASM_OP
1290 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
1291 CTORS_SECTION_ASM_OP, 1);
1292 #endif
1293 #ifdef DTORS_SECTION_ASM_OP
1294 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
1295 DTORS_SECTION_ASM_OP, 1);
1296 #endif
1297 #ifdef TEXT_SECTION_ASM_OP
1298 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
1299 TEXT_SECTION_ASM_OP, 1);
1300 #endif
1301 #ifdef INIT_SECTION_ASM_OP
1302 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
1303 INIT_SECTION_ASM_OP, 1);
1304 #endif
1305 #ifdef INIT_ARRAY_SECTION_ASM_OP
1306 /* Despite the name of this target macro, the expansion is not
1307 actually used, and may be empty rather than a string
1308 constant. */
1309 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
1310 #endif
1311
1312 /* For libgcc enable-execute-stack.c. */
1313 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
1314 TRAMPOLINE_SIZE);
1315
1316 /* For libgcc generic-morestack.c and unwinder code. */
1317 if (STACK_GROWS_DOWNWARD)
1318 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
1319
1320 /* For libgcc unwinder code. */
1321 #ifdef DONT_USE_BUILTIN_SETJMP
1322 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
1323 #endif
1324 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
1325 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
1326 DWARF_ALT_FRAME_RETURN_COLUMN);
1327 #endif
1328 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
1329 DWARF_FRAME_REGISTERS);
1330 #ifdef EH_RETURN_STACKADJ_RTX
1331 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
1332 #endif
1333 #ifdef JMP_BUF_SIZE
1334 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
1335 JMP_BUF_SIZE);
1336 #endif
1337 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
1338 STACK_POINTER_REGNUM);
1339
1340 /* For libgcov. */
1341 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
1342 TARGET_VTABLE_USES_DESCRIPTORS);
1343 }
1344
1345 /* For use in assembly language. */
1346 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
1347 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
1348
1349 /* Misc. */
1350 if (flag_gnu89_inline)
1351 cpp_define (pfile, "__GNUC_GNU_INLINE__");
1352 else
1353 cpp_define (pfile, "__GNUC_STDC_INLINE__");
1354
1355 if (flag_no_inline)
1356 cpp_define (pfile, "__NO_INLINE__");
1357
1358 if (flag_iso)
1359 cpp_define (pfile, "__STRICT_ANSI__");
1360
1361 if (!flag_signed_char)
1362 cpp_define (pfile, "__CHAR_UNSIGNED__");
1363
1364 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
1365 cpp_define (pfile, "__WCHAR_UNSIGNED__");
1366
1367 cpp_atomic_builtins (pfile);
1368
1369 #ifdef DWARF2_UNWIND_INFO
1370 if (dwarf2out_do_cfi_asm ())
1371 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
1372 #endif
1373
1374 /* Make the choice of ObjC runtime visible to source code. */
1375 if (c_dialect_objc () && flag_next_runtime)
1376 cpp_define (pfile, "__NEXT_RUNTIME__");
1377
1378 /* Show the availability of some target pragmas. */
1379 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
1380
1381 /* Make the choice of the stack protector runtime visible to source code.
1382 The macro names and values here were chosen for compatibility with an
1383 earlier implementation, i.e. ProPolice. */
1384 if (flag_stack_protect == 4)
1385 cpp_define (pfile, "__SSP_EXPLICIT__=4");
1386 if (flag_stack_protect == 3)
1387 cpp_define (pfile, "__SSP_STRONG__=3");
1388 if (flag_stack_protect == 2)
1389 cpp_define (pfile, "__SSP_ALL__=2");
1390 else if (flag_stack_protect == 1)
1391 cpp_define (pfile, "__SSP__=1");
1392
1393 if (flag_openacc)
1394 cpp_define (pfile, "_OPENACC=201306");
1395
1396 if (flag_openmp)
1397 cpp_define (pfile, "_OPENMP=201511");
1398
1399 for (i = 0; i < NUM_INT_N_ENTS; i ++)
1400 if (int_n_enabled_p[i])
1401 {
1402 char buf[15+20];
1403 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
1404 builtin_define_type_sizeof (buf,
1405 int_n_trees[i].signed_type);
1406 }
1407 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
1408 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
1409 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
1410 unsigned_ptrdiff_type_node);
1411
1412 /* A straightforward target hook doesn't work, because of problems
1413 linking that hook's body when part of non-C front ends. */
1414 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
1415 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
1416 # define builtin_define(TXT) cpp_define (pfile, TXT)
1417 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
1418 TARGET_CPU_CPP_BUILTINS ();
1419 TARGET_OS_CPP_BUILTINS ();
1420 TARGET_OBJFMT_CPP_BUILTINS ();
1421
1422 /* Support the __declspec keyword by turning them into attributes.
1423 Note that the current way we do this may result in a collision
1424 with predefined attributes later on. This can be solved by using
1425 one attribute, say __declspec__, and passing args to it. The
1426 problem with that approach is that args are not accumulated: each
1427 new appearance would clobber any existing args. */
1428 if (TARGET_DECLSPEC)
1429 builtin_define ("__declspec(x)=__attribute__((x))");
1430
1431 /* If decimal floating point is supported, tell the user if the
1432 alternate format (BID) is used instead of the standard (DPD)
1433 format. */
1434 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
1435 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
1436 }
1437
1438 /* Pass an object-like macro. If it doesn't lie in the user's
1439 namespace, defines it unconditionally. Otherwise define a version
1440 with two leading underscores, and another version with two leading
1441 and trailing underscores, and define the original only if an ISO
1442 standard was not nominated.
1443
1444 e.g. passing "unix" defines "__unix", "__unix__" and possibly
1445 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
1446 "_mips". */
1447 void
builtin_define_std(const char * macro)1448 builtin_define_std (const char *macro)
1449 {
1450 size_t len = strlen (macro);
1451 char *buff = (char *) alloca (len + 5);
1452 char *p = buff + 2;
1453 char *q = p + len;
1454
1455 /* prepend __ (or maybe just _) if in user's namespace. */
1456 memcpy (p, macro, len + 1);
1457 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
1458 {
1459 if (*p != '_')
1460 *--p = '_';
1461 if (p[1] != '_')
1462 *--p = '_';
1463 }
1464 cpp_define (parse_in, p);
1465
1466 /* If it was in user's namespace... */
1467 if (p != buff + 2)
1468 {
1469 /* Define the macro with leading and following __. */
1470 if (q[-1] != '_')
1471 *q++ = '_';
1472 if (q[-2] != '_')
1473 *q++ = '_';
1474 *q = '\0';
1475 cpp_define (parse_in, p);
1476
1477 /* Finally, define the original macro if permitted. */
1478 if (!flag_iso)
1479 cpp_define (parse_in, macro);
1480 }
1481 }
1482
1483 /* Pass an object-like macro and a value to define it to. The third
1484 parameter says whether or not to turn the value into a string
1485 constant. */
1486 void
builtin_define_with_value(const char * macro,const char * expansion,int is_str)1487 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
1488 {
1489 char *buf;
1490 size_t mlen = strlen (macro);
1491 size_t elen = strlen (expansion);
1492 size_t extra = 2; /* space for an = and a NUL */
1493
1494 if (is_str)
1495 {
1496 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
1497 const char *p;
1498 char *q;
1499 extra += 2; /* space for two quote marks */
1500 for (p = expansion, q = quoted_expansion; *p; p++)
1501 {
1502 switch (*p)
1503 {
1504 case '\n':
1505 *q++ = '\\';
1506 *q++ = 'n';
1507 break;
1508
1509 case '\t':
1510 *q++ = '\\';
1511 *q++ = 't';
1512 break;
1513
1514 case '\\':
1515 *q++ = '\\';
1516 *q++ = '\\';
1517 break;
1518
1519 case '"':
1520 *q++ = '\\';
1521 *q++ = '"';
1522 break;
1523
1524 default:
1525 if (ISPRINT ((unsigned char) *p))
1526 *q++ = *p;
1527 else
1528 {
1529 sprintf (q, "\\%03o", (unsigned char) *p);
1530 q += 4;
1531 }
1532 }
1533 }
1534 *q = '\0';
1535 expansion = quoted_expansion;
1536 elen = q - expansion;
1537 }
1538
1539 buf = (char *) alloca (mlen + elen + extra);
1540 if (is_str)
1541 sprintf (buf, "%s=\"%s\"", macro, expansion);
1542 else
1543 sprintf (buf, "%s=%s", macro, expansion);
1544
1545 cpp_define (parse_in, buf);
1546 }
1547
1548
1549 /* Pass an object-like macro and an integer value to define it to. */
1550 void
builtin_define_with_int_value(const char * macro,HOST_WIDE_INT value)1551 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
1552 {
1553 char *buf;
1554 size_t mlen = strlen (macro);
1555 size_t vlen = 18;
1556 size_t extra = 2; /* space for = and NUL. */
1557
1558 buf = (char *) alloca (mlen + vlen + extra);
1559 memcpy (buf, macro, mlen);
1560 buf[mlen] = '=';
1561 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
1562
1563 cpp_define (parse_in, buf);
1564 }
1565
1566 /* builtin_define_with_hex_fp_value is very expensive, so the following
1567 array and function allows it to be done lazily when __DBL_MAX__
1568 etc. is first used. */
1569
1570 struct GTY(()) lazy_hex_fp_value_struct
1571 {
1572 const char *hex_str;
1573 cpp_macro *macro;
1574 machine_mode mode;
1575 int digits;
1576 const char *fp_suffix;
1577 };
1578 /* Number of the expensive to compute macros we should evaluate lazily.
1579 Each builtin_define_float_constants invocation calls
1580 builtin_define_with_hex_fp_value 4 times and builtin_define_float_constants
1581 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
1582 FLTNN*. */
1583 #define LAZY_HEX_FP_VALUES_CNT (4 * (3 + NUM_FLOATN_NX_TYPES))
1584 static GTY(()) struct lazy_hex_fp_value_struct
1585 lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
1586 static GTY(()) int lazy_hex_fp_value_count;
1587
1588 static bool
lazy_hex_fp_value(cpp_reader * pfile ATTRIBUTE_UNUSED,cpp_hashnode * node)1589 lazy_hex_fp_value (cpp_reader *pfile ATTRIBUTE_UNUSED,
1590 cpp_hashnode *node)
1591 {
1592 REAL_VALUE_TYPE real;
1593 char dec_str[64], buf1[256];
1594 unsigned int idx;
1595 if (node->value.builtin < BT_FIRST_USER
1596 || (int) node->value.builtin >= BT_FIRST_USER + lazy_hex_fp_value_count)
1597 return false;
1598
1599 idx = node->value.builtin - BT_FIRST_USER;
1600 real_from_string (&real, lazy_hex_fp_values[idx].hex_str);
1601 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
1602 lazy_hex_fp_values[idx].digits, 0,
1603 lazy_hex_fp_values[idx].mode);
1604
1605 sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[idx].fp_suffix);
1606 node->flags &= ~(NODE_BUILTIN | NODE_USED);
1607 node->value.macro = lazy_hex_fp_values[idx].macro;
1608 for (idx = 0; idx < node->value.macro->count; idx++)
1609 if (node->value.macro->exp.tokens[idx].type == CPP_NUMBER)
1610 break;
1611 gcc_assert (idx < node->value.macro->count);
1612 node->value.macro->exp.tokens[idx].val.str.len = strlen (buf1);
1613 node->value.macro->exp.tokens[idx].val.str.text
1614 = (const unsigned char *) ggc_strdup (buf1);
1615 return true;
1616 }
1617
1618 /* Pass an object-like macro a hexadecimal floating-point value. */
1619 static void
builtin_define_with_hex_fp_value(const char * macro,tree type,int digits,const char * hex_str,const char * fp_suffix,const char * fp_cast)1620 builtin_define_with_hex_fp_value (const char *macro,
1621 tree type, int digits,
1622 const char *hex_str,
1623 const char *fp_suffix,
1624 const char *fp_cast)
1625 {
1626 REAL_VALUE_TYPE real;
1627 char dec_str[64], buf[256], buf1[128], buf2[64];
1628
1629 /* This is very expensive, so if possible expand them lazily. */
1630 if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
1631 && flag_dump_macros == 0
1632 && !cpp_get_options (parse_in)->traditional)
1633 {
1634 struct cpp_hashnode *node;
1635 if (lazy_hex_fp_value_count == 0)
1636 cpp_get_callbacks (parse_in)->user_builtin_macro = lazy_hex_fp_value;
1637 sprintf (buf2, fp_cast, "1.1");
1638 sprintf (buf1, "%s=%s", macro, buf2);
1639 cpp_define (parse_in, buf1);
1640 node = C_CPP_HASHNODE (get_identifier (macro));
1641 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
1642 = ggc_strdup (hex_str);
1643 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
1644 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
1645 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
1646 lazy_hex_fp_values[lazy_hex_fp_value_count].macro = node->value.macro;
1647 node->flags |= NODE_BUILTIN;
1648 node->value.builtin
1649 = (enum cpp_builtin_type) (BT_FIRST_USER + lazy_hex_fp_value_count);
1650 lazy_hex_fp_value_count++;
1651 return;
1652 }
1653
1654 /* Hex values are really cool and convenient, except that they're
1655 not supported in strict ISO C90 mode. First, the "p-" sequence
1656 is not valid as part of a preprocessor number. Second, we get a
1657 pedwarn from the preprocessor, which has no context, so we can't
1658 suppress the warning with __extension__.
1659
1660 So instead what we do is construct the number in hex (because
1661 it's easy to get the exact correct value), parse it as a real,
1662 then print it back out as decimal. */
1663
1664 real_from_string (&real, hex_str);
1665 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
1666 TYPE_MODE (type));
1667
1668 /* Assemble the macro in the following fashion
1669 macro = fp_cast [dec_str fp_suffix] */
1670 sprintf (buf2, "%s%s", dec_str, fp_suffix);
1671 sprintf (buf1, fp_cast, buf2);
1672 sprintf (buf, "%s=%s", macro, buf1);
1673
1674 cpp_define (parse_in, buf);
1675 }
1676
1677 /* Return a string constant for the suffix for a value of type TYPE
1678 promoted according to the integer promotions. The type must be one
1679 of the standard integer type nodes. */
1680
1681 static const char *
type_suffix(tree type)1682 type_suffix (tree type)
1683 {
1684 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
1685 int unsigned_suffix;
1686 int is_long;
1687 int tp = TYPE_PRECISION (type);
1688
1689 if (type == long_long_integer_type_node
1690 || type == long_long_unsigned_type_node
1691 || tp > TYPE_PRECISION (long_integer_type_node))
1692 is_long = 2;
1693 else if (type == long_integer_type_node
1694 || type == long_unsigned_type_node
1695 || tp > TYPE_PRECISION (integer_type_node))
1696 is_long = 1;
1697 else if (type == integer_type_node
1698 || type == unsigned_type_node
1699 || type == short_integer_type_node
1700 || type == short_unsigned_type_node
1701 || type == signed_char_type_node
1702 || type == unsigned_char_type_node
1703 /* ??? "char" is not a signed or unsigned integer type and
1704 so is not permitted for the standard typedefs, but some
1705 systems use it anyway. */
1706 || type == char_type_node)
1707 is_long = 0;
1708 else
1709 gcc_unreachable ();
1710
1711 unsigned_suffix = TYPE_UNSIGNED (type);
1712 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
1713 unsigned_suffix = 0;
1714 return suffixes[is_long * 2 + unsigned_suffix];
1715 }
1716
1717 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
1718 static void
builtin_define_constants(const char * macro,tree type)1719 builtin_define_constants (const char *macro, tree type)
1720 {
1721 const char *suffix;
1722 char *buf;
1723
1724 suffix = type_suffix (type);
1725
1726 if (suffix[0] == 0)
1727 {
1728 buf = (char *) alloca (strlen (macro) + 6);
1729 sprintf (buf, "%s(c)=c", macro);
1730 }
1731 else
1732 {
1733 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
1734 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
1735 }
1736
1737 cpp_define (parse_in, buf);
1738 }
1739
1740 /* Define MAX for TYPE based on the precision of the type. */
1741
1742 static void
builtin_define_type_max(const char * macro,tree type)1743 builtin_define_type_max (const char *macro, tree type)
1744 {
1745 builtin_define_type_minmax (NULL, macro, type);
1746 }
1747
1748 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
1749 representation of that value. For example, a COUNT of 10 would
1750 return "0x3ff". */
1751
1752 static void
print_bits_of_hex(char * buf,int bufsz,int count)1753 print_bits_of_hex (char *buf, int bufsz, int count)
1754 {
1755 gcc_assert (bufsz > 3);
1756 *buf++ = '0';
1757 *buf++ = 'x';
1758 bufsz -= 2;
1759
1760 gcc_assert (count > 0);
1761
1762 switch (count % 4) {
1763 case 0:
1764 break;
1765 case 1:
1766 *buf++ = '1';
1767 bufsz --;
1768 count -= 1;
1769 break;
1770 case 2:
1771 *buf++ = '3';
1772 bufsz --;
1773 count -= 2;
1774 break;
1775 case 3:
1776 *buf++ = '7';
1777 bufsz --;
1778 count -= 3;
1779 break;
1780 }
1781 while (count >= 4)
1782 {
1783 gcc_assert (bufsz > 1);
1784 *buf++ = 'f';
1785 bufsz --;
1786 count -= 4;
1787 }
1788 gcc_assert (bufsz > 0);
1789 *buf++ = 0;
1790 }
1791
1792 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
1793 precision of the type. */
1794
1795 static void
builtin_define_type_minmax(const char * min_macro,const char * max_macro,tree type)1796 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
1797 tree type)
1798 {
1799 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
1800 char value[PBOH_SZ];
1801
1802 const char *suffix;
1803 char *buf;
1804 int bits;
1805
1806 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
1807
1808 print_bits_of_hex (value, PBOH_SZ, bits);
1809
1810 suffix = type_suffix (type);
1811
1812 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
1813 + strlen (suffix) + 1);
1814 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
1815
1816 cpp_define (parse_in, buf);
1817
1818 if (min_macro)
1819 {
1820 if (TYPE_UNSIGNED (type))
1821 {
1822 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
1823 sprintf (buf, "%s=0%s", min_macro, suffix);
1824 }
1825 else
1826 {
1827 buf = (char *) alloca (strlen (min_macro) + 3
1828 + strlen (max_macro) + 6);
1829 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
1830 }
1831 cpp_define (parse_in, buf);
1832 }
1833 }
1834
1835 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
1836 both types must have the same width. */
1837
1838 static void
builtin_define_type_width(const char * width_macro,tree type,tree type2)1839 builtin_define_type_width (const char *width_macro, tree type, tree type2)
1840 {
1841 if (type2 != NULL_TREE)
1842 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
1843 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
1844 }
1845
1846 #include "gt-c-family-c-cppbuiltin.h"
1847