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