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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [c-cppbuiltin.c] - Blame information for rev 826

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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