OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [c-cppbuiltin.c] - Blame information for rev 853

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* Define builtin-in macros for the C family front ends.
2
   Copyright (C) 2002, 2003, 2004, 2005, 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 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 "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
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
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
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
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
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
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
 
521
  if (flag_iso)
522
    cpp_define (pfile, "__STRICT_ANSI__");
523
 
524
  if (!flag_signed_char)
525
    cpp_define (pfile, "__CHAR_UNSIGNED__");
526
 
527
  if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
528
    cpp_define (pfile, "__WCHAR_UNSIGNED__");
529
 
530
  /* Make the choice of ObjC runtime visible to source code.  */
531
  if (c_dialect_objc () && flag_next_runtime)
532
    cpp_define (pfile, "__NEXT_RUNTIME__");
533
 
534
  /* Show the availability of some target pragmas.  */
535
  if (flag_mudflap || targetm.handle_pragma_redefine_extname)
536
    cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
537
 
538
  if (targetm.handle_pragma_extern_prefix)
539
    cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
540
 
541
  /* Make the choice of the stack protector runtime visible to source code.
542
     The macro names and values here were chosen for compatibility with an
543
     earlier implementation, i.e. ProPolice.  */
544
  if (flag_stack_protect == 2)
545
    cpp_define (pfile, "__SSP_ALL__=2");
546
  else if (flag_stack_protect == 1)
547
    cpp_define (pfile, "__SSP__=1");
548
 
549
  if (flag_openmp)
550
    cpp_define (pfile, "_OPENMP=200505");
551
 
552
  /* A straightforward target hook doesn't work, because of problems
553
     linking that hook's body when part of non-C front ends.  */
554
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
555
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
556
# define builtin_define(TXT) cpp_define (pfile, TXT)
557
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
558
  TARGET_CPU_CPP_BUILTINS ();
559
  TARGET_OS_CPP_BUILTINS ();
560
  TARGET_OBJFMT_CPP_BUILTINS ();
561
 
562
  /* Support the __declspec keyword by turning them into attributes.
563
     Note that the current way we do this may result in a collision
564
     with predefined attributes later on.  This can be solved by using
565
     one attribute, say __declspec__, and passing args to it.  The
566
     problem with that approach is that args are not accumulated: each
567
     new appearance would clobber any existing args.  */
568
  if (TARGET_DECLSPEC)
569
    builtin_define ("__declspec(x)=__attribute__((x))");
570
}
571
 
572
/* Pass an object-like macro.  If it doesn't lie in the user's
573
   namespace, defines it unconditionally.  Otherwise define a version
574
   with two leading underscores, and another version with two leading
575
   and trailing underscores, and define the original only if an ISO
576
   standard was not nominated.
577
 
578
   e.g. passing "unix" defines "__unix", "__unix__" and possibly
579
   "unix".  Passing "_mips" defines "__mips", "__mips__" and possibly
580
   "_mips".  */
581
void
582
builtin_define_std (const char *macro)
583
{
584
  size_t len = strlen (macro);
585
  char *buff = (char *) alloca (len + 5);
586
  char *p = buff + 2;
587
  char *q = p + len;
588
 
589
  /* prepend __ (or maybe just _) if in user's namespace.  */
590
  memcpy (p, macro, len + 1);
591
  if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
592
    {
593
      if (*p != '_')
594
        *--p = '_';
595
      if (p[1] != '_')
596
        *--p = '_';
597
    }
598
  cpp_define (parse_in, p);
599
 
600
  /* If it was in user's namespace...  */
601
  if (p != buff + 2)
602
    {
603
      /* Define the macro with leading and following __.  */
604
      if (q[-1] != '_')
605
        *q++ = '_';
606
      if (q[-2] != '_')
607
        *q++ = '_';
608
      *q = '\0';
609
      cpp_define (parse_in, p);
610
 
611
      /* Finally, define the original macro if permitted.  */
612
      if (!flag_iso)
613
        cpp_define (parse_in, macro);
614
    }
615
}
616
 
617
/* Pass an object-like macro and a value to define it to.  The third
618
   parameter says whether or not to turn the value into a string
619
   constant.  */
620
void
621
builtin_define_with_value (const char *macro, const char *expansion, int is_str)
622
{
623
  char *buf;
624
  size_t mlen = strlen (macro);
625
  size_t elen = strlen (expansion);
626
  size_t extra = 2;  /* space for an = and a NUL */
627
 
628
  if (is_str)
629
    extra += 2;  /* space for two quote marks */
630
 
631
  buf = (char *) alloca (mlen + elen + extra);
632
  if (is_str)
633
    sprintf (buf, "%s=\"%s\"", macro, expansion);
634
  else
635
    sprintf (buf, "%s=%s", macro, expansion);
636
 
637
  cpp_define (parse_in, buf);
638
}
639
 
640
/* Pass an object-like macro and a value to define it to.  The third
641
   parameter is the length of the expansion.  */
642
static void
643
builtin_define_with_value_n (const char *macro, const char *expansion, size_t elen)
644
{
645
  char *buf;
646
  size_t mlen = strlen (macro);
647
 
648
  /* Space for an = and a NUL.  */
649
  buf = (char *) alloca (mlen + elen + 2);
650
  memcpy (buf, macro, mlen);
651
  buf[mlen] = '=';
652
  memcpy (buf + mlen + 1, expansion, elen);
653
  buf[mlen + elen + 1] = '\0';
654
 
655
  cpp_define (parse_in, buf);
656
}
657
 
658
/* Pass an object-like macro and an integer value to define it to.  */
659
static void
660
builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
661
{
662
  char *buf;
663
  size_t mlen = strlen (macro);
664
  size_t vlen = 18;
665
  size_t extra = 2; /* space for = and NUL.  */
666
 
667
  buf = (char *) alloca (mlen + vlen + extra);
668
  memcpy (buf, macro, mlen);
669
  buf[mlen] = '=';
670
  sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
671
 
672
  cpp_define (parse_in, buf);
673
}
674
 
675
/* Pass an object-like macro a hexadecimal floating-point value.  */
676
static void
677
builtin_define_with_hex_fp_value (const char *macro,
678
                                  tree type ATTRIBUTE_UNUSED, int digits,
679
                                  const char *hex_str,
680
                                  const char *fp_suffix,
681
                                  const char *fp_cast)
682
{
683
  REAL_VALUE_TYPE real;
684
  char dec_str[64], buf1[256], buf2[256];
685
 
686
  /* Hex values are really cool and convenient, except that they're
687
     not supported in strict ISO C90 mode.  First, the "p-" sequence
688
     is not valid as part of a preprocessor number.  Second, we get a
689
     pedwarn from the preprocessor, which has no context, so we can't
690
     suppress the warning with __extension__.
691
 
692
     So instead what we do is construct the number in hex (because
693
     it's easy to get the exact correct value), parse it as a real,
694
     then print it back out as decimal.  */
695
 
696
  real_from_string (&real, hex_str);
697
  real_to_decimal (dec_str, &real, sizeof (dec_str), digits, 0);
698
 
699
  /* Assemble the macro in the following fashion
700
     macro = fp_cast [dec_str fp_suffix] */
701
  sprintf (buf1, "%s%s", dec_str, fp_suffix);
702
  sprintf (buf2, fp_cast, buf1);
703
  sprintf (buf1, "%s=%s", macro, buf2);
704
 
705
  cpp_define (parse_in, buf1);
706
}
707
 
708
/* Define MAX for TYPE based on the precision of the type.  IS_LONG is
709
   1 for type "long" and 2 for "long long".  We have to handle
710
   unsigned types, since wchar_t might be unsigned.  */
711
 
712
static void
713
builtin_define_type_max (const char *macro, tree type, int is_long)
714
{
715
  static const char *const values[]
716
    = { "127", "255",
717
        "32767", "65535",
718
        "2147483647", "4294967295",
719
        "9223372036854775807", "18446744073709551615",
720
        "170141183460469231731687303715884105727",
721
        "340282366920938463463374607431768211455" };
722
  static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
723
 
724
  const char *value, *suffix;
725
  char *buf;
726
  size_t idx;
727
 
728
  /* Pre-rendering the values mean we don't have to futz with printing a
729
     multi-word decimal value.  There are also a very limited number of
730
     precisions that we support, so it's really a waste of time.  */
731
  switch (TYPE_PRECISION (type))
732
    {
733
    case 8:     idx = 0; break;
734
    case 16:    idx = 2; break;
735
    case 32:    idx = 4; break;
736
    case 64:    idx = 6; break;
737
    case 128:   idx = 8; break;
738
    default:    gcc_unreachable ();
739
    }
740
 
741
  value = values[idx + TYPE_UNSIGNED (type)];
742
  suffix = suffixes[is_long * 2 + TYPE_UNSIGNED (type)];
743
 
744
  buf = (char *) alloca (strlen (macro) + 1 + strlen (value)
745
                         + strlen (suffix) + 1);
746
  sprintf (buf, "%s=%s%s", macro, value, suffix);
747
 
748
  cpp_define (parse_in, buf);
749
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.