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