1 /* Define builtin-in macros for the C family front ends.
2 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
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 2, 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 COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "tree.h"
27 #include "version.h"
28 #include "flags.h"
29 #include "real.h"
30 #include "c-common.h"
31 #include "c-pragma.h"
32 #include "output.h"
33 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
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_value_n (const char *, const char *,
53 size_t);
54 static void builtin_define_with_int_value (const char *, HOST_WIDE_INT);
55 static void builtin_define_with_hex_fp_value (const char *, tree,
56 int, const char *,
57 const char *,
58 const char *);
59 static void builtin_define_stdint_macros (void);
60 static void builtin_define_type_max (const char *, tree, int);
61 static void builtin_define_type_precision (const char *, tree);
62 static void builtin_define_float_constants (const char *,
63 const char *,
64 const char *,
65 tree);
66 static void define__GNUC__ (void);
67
68 /* Define NAME with value TYPE precision. */
69 static void
builtin_define_type_precision(const char * name,tree type)70 builtin_define_type_precision (const char *name, tree type)
71 {
72 builtin_define_with_int_value (name, TYPE_PRECISION (type));
73 }
74
75 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
76 and FP_CAST. */
77 static void
builtin_define_float_constants(const char * name_prefix,const char * fp_suffix,const char * fp_cast,tree type)78 builtin_define_float_constants (const char *name_prefix,
79 const char *fp_suffix,
80 const char *fp_cast,
81 tree type)
82 {
83 /* Used to convert radix-based values to base 10 values in several cases.
84
85 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
86 least 6 significant digits for correct results. Using the fraction
87 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
88 intermediate; perhaps someone can find a better approximation, in the
89 mean time, I suspect using doubles won't harm the bootstrap here. */
90
91 const double log10_2 = .30102999566398119521;
92 double log10_b;
93 const struct real_format *fmt;
94
95 char name[64], buf[128];
96 int dig, min_10_exp, max_10_exp;
97 int decimal_dig;
98
99 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
100 gcc_assert (fmt->b != 10);
101
102 /* The radix of the exponent representation. */
103 if (type == float_type_node)
104 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
105 log10_b = log10_2 * fmt->log2_b;
106
107 /* The number of radix digits, p, in the floating-point significand. */
108 sprintf (name, "__%s_MANT_DIG__", name_prefix);
109 builtin_define_with_int_value (name, fmt->p);
110
111 /* The number of decimal digits, q, such that any floating-point number
112 with q decimal digits can be rounded into a floating-point number with
113 p radix b digits and back again without change to the q decimal digits,
114
115 p log10 b if b is a power of 10
116 floor((p - 1) log10 b) otherwise
117 */
118 dig = (fmt->p - 1) * log10_b;
119 sprintf (name, "__%s_DIG__", name_prefix);
120 builtin_define_with_int_value (name, dig);
121
122 /* The minimum negative int x such that b**(x-1) is a normalized float. */
123 sprintf (name, "__%s_MIN_EXP__", name_prefix);
124 sprintf (buf, "(%d)", fmt->emin);
125 builtin_define_with_value (name, buf, 0);
126
127 /* The minimum negative int x such that 10**x is a normalized float,
128
129 ceil (log10 (b ** (emin - 1)))
130 = ceil (log10 (b) * (emin - 1))
131
132 Recall that emin is negative, so the integer truncation calculates
133 the ceiling, not the floor, in this case. */
134 min_10_exp = (fmt->emin - 1) * log10_b;
135 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
136 sprintf (buf, "(%d)", min_10_exp);
137 builtin_define_with_value (name, buf, 0);
138
139 /* The maximum int x such that b**(x-1) is a representable float. */
140 sprintf (name, "__%s_MAX_EXP__", name_prefix);
141 builtin_define_with_int_value (name, fmt->emax);
142
143 /* The maximum int x such that 10**x is in the range of representable
144 finite floating-point numbers,
145
146 floor (log10((1 - b**-p) * b**emax))
147 = floor (log10(1 - b**-p) + log10(b**emax))
148 = floor (log10(1 - b**-p) + log10(b)*emax)
149
150 The safest thing to do here is to just compute this number. But since
151 we don't link cc1 with libm, we cannot. We could implement log10 here
152 a series expansion, but that seems too much effort because:
153
154 Note that the first term, for all extant p, is a number exceedingly close
155 to zero, but slightly negative. Note that the second term is an integer
156 scaling an irrational number, and that because of the floor we are only
157 interested in its integral portion.
158
159 In order for the first term to have any effect on the integral portion
160 of the second term, the second term has to be exceedingly close to an
161 integer itself (e.g. 123.000000000001 or something). Getting a result
162 that close to an integer requires that the irrational multiplicand have
163 a long series of zeros in its expansion, which doesn't occur in the
164 first 20 digits or so of log10(b).
165
166 Hand-waving aside, crunching all of the sets of constants above by hand
167 does not yield a case for which the first term is significant, which
168 in the end is all that matters. */
169 max_10_exp = fmt->emax * log10_b;
170 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
171 builtin_define_with_int_value (name, max_10_exp);
172
173 /* The number of decimal digits, n, such that any floating-point number
174 can be rounded to n decimal digits and back again without change to
175 the value.
176
177 p * log10(b) if b is a power of 10
178 ceil(1 + p * log10(b)) otherwise
179
180 The only macro we care about is this number for the widest supported
181 floating type, but we want this value for rendering constants below. */
182 {
183 double d_decimal_dig = 1 + fmt->p * log10_b;
184 decimal_dig = d_decimal_dig;
185 if (decimal_dig < d_decimal_dig)
186 decimal_dig++;
187 }
188 if (type == long_double_type_node)
189 builtin_define_with_int_value ("__DECIMAL_DIG__", decimal_dig);
190
191 /* Since, for the supported formats, B is always a power of 2, we
192 construct the following numbers directly as a hexadecimal
193 constants. */
194
195 /* The maximum representable finite floating-point number,
196 (1 - b**-p) * b**emax */
197 {
198 int i, n;
199 char *p;
200
201 strcpy (buf, "0x0.");
202 n = fmt->p * fmt->log2_b;
203 for (i = 0, p = buf + 4; i + 3 < n; i += 4)
204 *p++ = 'f';
205 if (i < n)
206 *p++ = "08ce"[n - i];
207 sprintf (p, "p%d", fmt->emax * fmt->log2_b);
208 if (fmt->pnan < fmt->p)
209 {
210 /* This is an IBM extended double format made up of two IEEE
211 doubles. The value of the long double is the sum of the
212 values of the two parts. The most significant part is
213 required to be the value of the long double rounded to the
214 nearest double. Rounding means we need a slightly smaller
215 value for LDBL_MAX. */
216 buf[4 + fmt->pnan / 4] = "7bde"[fmt->pnan % 4];
217 }
218 }
219 sprintf (name, "__%s_MAX__", name_prefix);
220 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
221
222 /* The minimum normalized positive floating-point number,
223 b**(emin-1). */
224 sprintf (name, "__%s_MIN__", name_prefix);
225 sprintf (buf, "0x1p%d", (fmt->emin - 1) * fmt->log2_b);
226 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
227
228 /* The difference between 1 and the least value greater than 1 that is
229 representable in the given floating point type, b**(1-p). */
230 sprintf (name, "__%s_EPSILON__", name_prefix);
231 if (fmt->pnan < fmt->p)
232 /* This is an IBM extended double format, so 1.0 + any double is
233 representable precisely. */
234 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
235 else
236 sprintf (buf, "0x1p%d", (1 - fmt->p) * fmt->log2_b);
237 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
238
239 /* For C++ std::numeric_limits<T>::denorm_min. The minimum denormalized
240 positive floating-point number, b**(emin-p). Zero for formats that
241 don't support denormals. */
242 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
243 if (fmt->has_denorm)
244 {
245 sprintf (buf, "0x1p%d", (fmt->emin - fmt->p) * fmt->log2_b);
246 builtin_define_with_hex_fp_value (name, type, decimal_dig,
247 buf, fp_suffix, fp_cast);
248 }
249 else
250 {
251 sprintf (buf, "0.0%s", fp_suffix);
252 builtin_define_with_value (name, buf, 0);
253 }
254
255 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
256 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
257
258 /* For C++ std::numeric_limits<T>::has_infinity. */
259 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
260 builtin_define_with_int_value (name,
261 MODE_HAS_INFINITIES (TYPE_MODE (type)));
262 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
263 predicate to distinguish a target that has both quiet and
264 signalling NaNs from a target that has only quiet NaNs or only
265 signalling NaNs, so we assume that a target that has any kind of
266 NaN has quiet NaNs. */
267 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
268 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
269 }
270
271 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
272 static void
builtin_define_decimal_float_constants(const char * name_prefix,const char * suffix,tree type)273 builtin_define_decimal_float_constants (const char *name_prefix,
274 const char *suffix,
275 tree type)
276 {
277 const struct real_format *fmt;
278 char name[64], buf[128], *p;
279 int digits;
280
281 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
282
283 /* The number of radix digits, p, in the significand. */
284 sprintf (name, "__%s_MANT_DIG__", name_prefix);
285 builtin_define_with_int_value (name, fmt->p);
286
287 /* The minimum negative int x such that b**(x-1) is a normalized float. */
288 sprintf (name, "__%s_MIN_EXP__", name_prefix);
289 sprintf (buf, "(%d)", fmt->emin);
290 builtin_define_with_value (name, buf, 0);
291
292 /* The maximum int x such that b**(x-1) is a representable float. */
293 sprintf (name, "__%s_MAX_EXP__", name_prefix);
294 builtin_define_with_int_value (name, fmt->emax);
295
296 /* Compute the minimum representable value. */
297 sprintf (name, "__%s_MIN__", name_prefix);
298 sprintf (buf, "1E%d%s", fmt->emin, suffix);
299 builtin_define_with_value (name, buf, 0);
300
301 /* Compute the maximum representable value. */
302 sprintf (name, "__%s_MAX__", name_prefix);
303 p = buf;
304 for (digits = fmt->p; digits; digits--)
305 {
306 *p++ = '9';
307 if (digits == fmt->p)
308 *p++ = '.';
309 }
310 *p = 0;
311 /* fmt->p plus 1, to account for the decimal point. */
312 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax, suffix);
313 builtin_define_with_value (name, buf, 0);
314
315 /* Compute epsilon (the difference between 1 and least value greater
316 than 1 representable). */
317 sprintf (name, "__%s_EPSILON__", name_prefix);
318 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
319 builtin_define_with_value (name, buf, 0);
320
321 /* Minimum denormalized postive decimal value. */
322 sprintf (name, "__%s_DEN__", name_prefix);
323 p = buf;
324 for (digits = fmt->p; digits > 1; digits--)
325 {
326 *p++ = '0';
327 if (digits == fmt->p)
328 *p++ = '.';
329 }
330 *p = 0;
331 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin, suffix);
332 builtin_define_with_value (name, buf, 0);
333 }
334
335 /* Define __GNUC__, __GNUC_MINOR__ and __GNUC_PATCHLEVEL__. */
336 static void
define__GNUC__(void)337 define__GNUC__ (void)
338 {
339 /* The format of the version string, enforced below, is
340 ([^0-9]*-)?[0-9]+[.][0-9]+([.][0-9]+)?([- ].*)? */
341 const char *q, *v = version_string;
342
343 while (*v && !ISDIGIT (*v))
344 v++;
345 gcc_assert (*v && (v <= version_string || v[-1] == '-'));
346
347 q = v;
348 while (ISDIGIT (*v))
349 v++;
350 builtin_define_with_value_n ("__GNUC__", q, v - q);
351 if (c_dialect_cxx ())
352 builtin_define_with_value_n ("__GNUG__", q, v - q);
353
354 gcc_assert (*v == '.' && ISDIGIT (v[1]));
355
356 q = ++v;
357 while (ISDIGIT (*v))
358 v++;
359 builtin_define_with_value_n ("__GNUC_MINOR__", q, v - q);
360
361 if (*v == '.')
362 {
363 gcc_assert (ISDIGIT (v[1]));
364 q = ++v;
365 while (ISDIGIT (*v))
366 v++;
367 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", q, v - q);
368 }
369 else
370 builtin_define_with_value_n ("__GNUC_PATCHLEVEL__", "0", 1);
371
372 gcc_assert (!*v || *v == ' ' || *v == '-');
373 }
374
375 /* Define macros used by <stdint.h>. Currently only defines limits
376 for intmax_t, used by the testsuite. */
377 static void
builtin_define_stdint_macros(void)378 builtin_define_stdint_macros (void)
379 {
380 int intmax_long;
381 if (intmax_type_node == long_long_integer_type_node)
382 intmax_long = 2;
383 else if (intmax_type_node == long_integer_type_node)
384 intmax_long = 1;
385 else if (intmax_type_node == integer_type_node)
386 intmax_long = 0;
387 else
388 gcc_unreachable ();
389 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node, intmax_long);
390 }
391
392 /* Hook that registers front end and target-specific built-ins. */
393 void
c_cpp_builtins(cpp_reader * pfile)394 c_cpp_builtins (cpp_reader *pfile)
395 {
396 /* -undef turns off target-specific built-ins. */
397 if (flag_undef)
398 return;
399
400 define__GNUC__ ();
401
402 /* For stddef.h. They require macros defined in c-common.c. */
403 c_stddef_cpp_builtins ();
404
405 if (c_dialect_cxx ())
406 {
407 if (flag_weak && SUPPORTS_ONE_ONLY)
408 cpp_define (pfile, "__GXX_WEAK__=1");
409 else
410 cpp_define (pfile, "__GXX_WEAK__=0");
411 if (warn_deprecated)
412 cpp_define (pfile, "__DEPRECATED");
413 }
414 /* Note that we define this for C as well, so that we know if
415 __attribute__((cleanup)) will interface with EH. */
416 if (flag_exceptions)
417 cpp_define (pfile, "__EXCEPTIONS");
418
419 /* Represents the C++ ABI version, always defined so it can be used while
420 preprocessing C and assembler. */
421 if (flag_abi_version == 0)
422 /* Use a very large value so that:
423
424 #if __GXX_ABI_VERSION >= <value for version X>
425
426 will work whether the user explicitly says "-fabi-version=x" or
427 "-fabi-version=0". Do not use INT_MAX because that will be
428 different from system to system. */
429 builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
430 else if (flag_abi_version == 1)
431 /* Due to a historical accident, this version had the value
432 "102". */
433 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
434 else
435 /* Newer versions have values 1002, 1003, .... */
436 builtin_define_with_int_value ("__GXX_ABI_VERSION",
437 1000 + flag_abi_version);
438
439 /* libgcc needs to know this. */
440 if (USING_SJLJ_EXCEPTIONS)
441 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
442
443 /* limits.h needs to know these. */
444 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
445 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
446 builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
447 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
448 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
449 builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
450
451 builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
452
453 /* stdint.h (eventually) and the testsuite need to know these. */
454 builtin_define_stdint_macros ();
455
456 /* float.h needs to know these. */
457
458 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
459 TARGET_FLT_EVAL_METHOD);
460
461 /* And decfloat.h needs this. */
462 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
463 TARGET_DEC_EVAL_METHOD);
464
465 builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
466 /* Cast the double precision constants when single precision constants are
467 specified. The correct result is computed by the compiler when using
468 macros that include a cast. This has the side-effect of making the value
469 unusable in const expressions. */
470 if (flag_single_precision_constant)
471 builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
472 else
473 builtin_define_float_constants ("DBL", "", "%s", double_type_node);
474 builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
475
476 /* For decfloat.h. */
477 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
478 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
479 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
480
481 /* For use in assembly language. */
482 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
483 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
484
485 /* Misc. */
486 builtin_define_with_value ("__VERSION__", version_string, 1);
487
488 if (flag_gnu89_inline)
489 cpp_define (pfile, "__GNUC_GNU_INLINE__");
490 else
491 cpp_define (pfile, "__GNUC_STDC_INLINE__");
492
493 /* Definitions for LP64 model. */
494 if (TYPE_PRECISION (long_integer_type_node) == 64
495 && POINTER_SIZE == 64
496 && TYPE_PRECISION (integer_type_node) == 32)
497 {
498 cpp_define (pfile, "_LP64");
499 cpp_define (pfile, "__LP64__");
500 }
501
502 /* Other target-independent built-ins determined by command-line
503 options. */
504 /* APPLE LOCAL begin blocks */
505 /* APPLE LOCAL radar 5868913 */
506 if (flag_blocks)
507 {
508 cpp_define (pfile, "__block=__attribute__((__blocks__(byref)))");
509 cpp_define (pfile, "__BLOCKS__=1");
510 }
511 /* APPLE LOCAL end blocks */
512 if (optimize_size)
513 cpp_define (pfile, "__OPTIMIZE_SIZE__");
514 if (optimize)
515 cpp_define (pfile, "__OPTIMIZE__");
516
517 if (fast_math_flags_set_p ())
518 cpp_define (pfile, "__FAST_MATH__");
519 if (flag_really_no_inline)
520 cpp_define (pfile, "__NO_INLINE__");
521 if (flag_signaling_nans)
522 cpp_define (pfile, "__SUPPORT_SNAN__");
523 if (flag_finite_math_only)
524 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
525 else
526 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
527 if (flag_pic)
528 {
529 builtin_define_with_int_value ("__pic__", flag_pic);
530 builtin_define_with_int_value ("__PIC__", flag_pic);
531 }
532
533 if (flag_iso)
534 cpp_define (pfile, "__STRICT_ANSI__");
535
536 if (!flag_signed_char)
537 cpp_define (pfile, "__CHAR_UNSIGNED__");
538
539 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
540 cpp_define (pfile, "__WCHAR_UNSIGNED__");
541
542 /* Make the choice of ObjC runtime visible to source code. */
543 if (c_dialect_objc () && flag_next_runtime)
544 cpp_define (pfile, "__NEXT_RUNTIME__");
545
546 /* Show the availability of some target pragmas. */
547 if (flag_mudflap || targetm.handle_pragma_redefine_extname)
548 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
549
550 if (targetm.handle_pragma_extern_prefix)
551 cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
552
553 /* Make the choice of the stack protector runtime visible to source code.
554 The macro names and values here were chosen for compatibility with an
555 earlier implementation, i.e. ProPolice. */
556 if (flag_stack_protect == 3)
557 cpp_define (pfile, "__SSP_STRONG__=3");
558 else if (flag_stack_protect == 2)
559 cpp_define (pfile, "__SSP_ALL__=2");
560 else if (flag_stack_protect == 1)
561 cpp_define (pfile, "__SSP__=1");
562
563 if (flag_openmp)
564 cpp_define (pfile, "_OPENMP=200505");
565
566 /* A straightforward target hook doesn't work, because of problems
567 linking that hook's body when part of non-C front ends. */
568 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
569 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
570 # define builtin_define(TXT) cpp_define (pfile, TXT)
571 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
572 TARGET_CPU_CPP_BUILTINS ();
573 TARGET_OS_CPP_BUILTINS ();
574 TARGET_OBJFMT_CPP_BUILTINS ();
575
576 /* Support the __declspec keyword by turning them into attributes.
577 Note that the current way we do this may result in a collision
578 with predefined attributes later on. This can be solved by using
579 one attribute, say __declspec__, and passing args to it. The
580 problem with that approach is that args are not accumulated: each
581 new appearance would clobber any existing args. */
582 if (TARGET_DECLSPEC)
583 builtin_define ("__declspec(x)=__attribute__((x))");
584 }
585
586 /* Pass an object-like macro. If it doesn't lie in the user's
587 namespace, defines it unconditionally. Otherwise define a version
588 with two leading underscores, and another version with two leading
589 and trailing underscores, and define the original only if an ISO
590 standard was not nominated.
591
592 e.g. passing "unix" defines "__unix", "__unix__" and possibly
593 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
594 "_mips". */
595 void
builtin_define_std(const char * macro)596 builtin_define_std (const char *macro)
597 {
598 size_t len = strlen (macro);
599 char *buff = (char *) alloca (len + 5);
600 char *p = buff + 2;
601 char *q = p + len;
602
603 /* prepend __ (or maybe just _) if in user's namespace. */
604 memcpy (p, macro, len + 1);
605 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
606 {
607 if (*p != '_')
608 *--p = '_';
609 if (p[1] != '_')
610 *--p = '_';
611 }
612 cpp_define (parse_in, p);
613
614 /* If it was in user's namespace... */
615 if (p != buff + 2)
616 {
617 /* Define the macro with leading and following __. */
618 if (q[-1] != '_')
619 *q++ = '_';
620 if (q[-2] != '_')
621 *q++ = '_';
622 *q = '\0';
623 cpp_define (parse_in, p);
624
625 /* Finally, define the original macro if permitted. */
626 if (!flag_iso)
627 cpp_define (parse_in, macro);
628 }
629 }
630
631 /* Pass an object-like macro and a value to define it to. The third
632 parameter says whether or not to turn the value into a string
633 constant. */
634 void
builtin_define_with_value(const char * macro,const char * expansion,int is_str)635 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
636 {
637 char *buf;
638 size_t mlen = strlen (macro);
639 size_t elen = strlen (expansion);
640 size_t extra = 2; /* space for an = and a NUL */
641
642 if (is_str)
643 extra += 2; /* space for two quote marks */
644
645 buf = (char *) alloca (mlen + elen + extra);
646 if (is_str)
647 sprintf (buf, "%s=\"%s\"", macro, expansion);
648 else
649 sprintf (buf, "%s=%s", macro, expansion);
650
651 cpp_define (parse_in, buf);
652 }
653
654 /* Pass an object-like macro and a value to define it to. The third
655 parameter is the length of the expansion. */
656 static void
builtin_define_with_value_n(const char * macro,const char * expansion,size_t elen)657 builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
658 {
659 char *buf;
660 size_t mlen = strlen (macro);
661
662 /* Space for an = and a NUL. */
663 buf = (char *) alloca (mlen + elen + 2);
664 memcpy (buf, macro, mlen);
665 buf[mlen] = '=';
666 memcpy (buf + mlen + 1, expansion, elen);
667 buf[mlen + elen + 1] = '\0';
668
669 cpp_define (parse_in, buf);
670 }
671
672 /* Pass an object-like macro and an integer value to define it to. */
673 static void
builtin_define_with_int_value(const char * macro,HOST_WIDE_INT value)674 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
675 {
676 char *buf;
677 size_t mlen = strlen (macro);
678 size_t vlen = 18;
679 size_t extra = 2; /* space for = and NUL. */
680
681 buf = (char *) alloca (mlen + vlen + extra);
682 memcpy (buf, macro, mlen);
683 buf[mlen] = '=';
684 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
685
686 cpp_define (parse_in, buf);
687 }
688
689 /* Pass an object-like macro a hexadecimal floating-point value. */
690 static void
builtin_define_with_hex_fp_value(const char * macro,tree type ATTRIBUTE_UNUSED,int digits,const char * hex_str,const char * fp_suffix,const char * fp_cast)691 builtin_define_with_hex_fp_value (const char *macro,
692 tree type ATTRIBUTE_UNUSED, int digits,
693 const char *hex_str,
694 const char *fp_suffix,
695 const char *fp_cast)
696 {
697 REAL_VALUE_TYPE real;
698 char dec_str[64], buf1[256], buf2[256];
699
700 /* Hex values are really cool and convenient, except that they're
701 not supported in strict ISO C90 mode. First, the "p-" sequence
702 is not valid as part of a preprocessor number. Second, we get a
703 pedwarn from the preprocessor, which has no context, so we can't
704 suppress the warning with __extension__.
705
706 So instead what we do is construct the number in hex (because
707 it's easy to get the exact correct value), parse it as a real,
708 then print it back out as decimal. */
709
710 real_from_string (&real, hex_str);
711 real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
712
713 /* Assemble the macro in the following fashion
714 macro = fp_cast [dec_str fp_suffix] */
715 sprintf (buf1, "%s%s", dec_str, fp_suffix);
716 sprintf (buf2, fp_cast, buf1);
717 sprintf (buf1, "%s=%s", macro, buf2);
718
719 cpp_define (parse_in, buf1);
720 }
721
722 /* Define MAX for TYPE based on the precision of the type. IS_LONG is
723 1 for type "long" and 2 for "long long". We have to handle
724 unsigned types, since wchar_t might be unsigned. */
725
726 static void
builtin_define_type_max(const char * macro,tree type,int is_long)727 builtin_define_type_max (const char *macro, tree type, int is_long)
728 {
729 static const char *const values[]
730 = { "127", "255",
731 "32767", "65535",
732 "2147483647", "4294967295",
733 "9223372036854775807", "18446744073709551615",
734 "170141183460469231731687303715884105727",
735 "340282366920938463463374607431768211455" };
736 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
737
738 const char *value, *suffix;
739 char *buf;
740 size_t idx;
741
742 /* Pre-rendering the values mean we don't have to futz with printing a
743 multi-word decimal value. There are also a very limited number of
744 precisions that we support, so it's really a waste of time. */
745 switch (TYPE_PRECISION (type))
746 {
747 case 8: idx = 0; break;
748 case 16: idx = 2; break;
749 case 32: idx = 4; break;
750 case 64: idx = 6; break;
751 case 128: idx = 8; break;
752 default: gcc_unreachable ();
753 }
754
755 value = values[idx + TYPE_UNSIGNED (type)];
756 suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
757
758 buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
759 + strlen (suffix) + 1);
760 sprintf (buf, "%s=%s%s", macro, value, suffix);
761
762 cpp_define (parse_in, buf);
763 }
764