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