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