68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 /* Define builtin-in macros for the C family front ends.
|
|
131
|
2 Copyright (C) 2002-2018 Free Software Foundation, Inc.
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
3
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4 This file is part of GCC.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 GCC is free software; you can redistribute it and/or modify it under
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7 the terms of the GNU General Public License as published by the Free
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 Software Foundation; either version 3, or (at your option) any later
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 version.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 for more details.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 You should have received a copy of the GNU General Public License
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 along with GCC; see the file COPYING3. If not see
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18 <http://www.gnu.org/licenses/>. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
19
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
20 #include "config.h"
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
21 #include "system.h"
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
22 #include "coretypes.h"
|
|
111
|
23 #include "target.h"
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24 #include "c-common.h"
|
|
111
|
25 #include "memmodel.h"
|
|
|
26 #include "tm_p.h" /* For TARGET_CPU_CPP_BUILTINS & friends. */
|
|
|
27 #include "stringpool.h"
|
|
|
28 #include "stor-layout.h"
|
|
|
29 #include "flags.h"
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
30 #include "c-pragma.h"
|
|
111
|
31 #include "output.h" /* For user_label_prefix. */
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
32 #include "debug.h" /* For dwarf2out_do_cfi_asm. */
|
|
111
|
33 #include "common/common-target.h"
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
34 #include "cppbuiltin.h"
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
35
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
36 #ifndef TARGET_OS_CPP_BUILTINS
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
37 # define TARGET_OS_CPP_BUILTINS()
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
38 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
39
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
40 #ifndef TARGET_OBJFMT_CPP_BUILTINS
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
41 # define TARGET_OBJFMT_CPP_BUILTINS()
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
42 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
43
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
44 #ifndef REGISTER_PREFIX
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
45 #define REGISTER_PREFIX ""
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
46 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
47
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
48 /* Non-static as some targets don't use it. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
49 static void builtin_define_with_hex_fp_value (const char *, tree,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
50 int, const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
51 const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
52 const char *);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
53 static void builtin_define_stdint_macros (void);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
54 static void builtin_define_constants (const char *, tree);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
55 static void builtin_define_type_max (const char *, tree);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
56 static void builtin_define_type_minmax (const char *, const char *, tree);
|
|
111
|
57 static void builtin_define_type_width (const char *, tree, tree);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
58 static void builtin_define_float_constants (const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
59 const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
60 const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
61 const char *,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
62 tree);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
63
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
64 /* Return true if MODE provides a fast multiply/add (FMA) builtin function.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
65 Originally this function used the fma optab, but that doesn't work with
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
66 -save-temps, so just rely on the HAVE_fma macros for the standard floating
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
67 point types. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
68
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
69 static bool
|
|
111
|
70 mode_has_fma (machine_mode mode)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
71 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
72 switch (mode)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
73 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
74 #ifdef HAVE_fmasf4
|
|
111
|
75 case E_SFmode:
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
76 return !!HAVE_fmasf4;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
77 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
78
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
79 #ifdef HAVE_fmadf4
|
|
111
|
80 case E_DFmode:
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
81 return !!HAVE_fmadf4;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
82 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
83
|
|
131
|
84 #ifdef HAVE_fmakf4 /* PowerPC if long double != __float128. */
|
|
|
85 case E_KFmode:
|
|
|
86 return !!HAVE_fmakf4;
|
|
|
87 #endif
|
|
|
88
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
89 #ifdef HAVE_fmaxf4
|
|
111
|
90 case E_XFmode:
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
91 return !!HAVE_fmaxf4;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
92 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
93
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
94 #ifdef HAVE_fmatf4
|
|
111
|
95 case E_TFmode:
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
96 return !!HAVE_fmatf4;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
97 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
98
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
99 default:
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
100 break;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
101 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
102
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
103 return false;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
104 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
105
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
106 /* Define NAME with value TYPE size_unit. */
|
|
111
|
107 void
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
108 builtin_define_type_sizeof (const char *name, tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
109 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
110 builtin_define_with_int_value (name,
|
|
111
|
111 tree_to_uhwi (TYPE_SIZE_UNIT (type)));
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
112 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
113
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
114 /* Define the float.h constants for TYPE using NAME_PREFIX, FP_SUFFIX,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
115 and FP_CAST. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
116 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
117 builtin_define_float_constants (const char *name_prefix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
118 const char *fp_suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
119 const char *fp_cast,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
120 const char *fma_suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
121 tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
122 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
123 /* Used to convert radix-based values to base 10 values in several cases.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
124
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
125 In the max_exp -> max_10_exp conversion for 128-bit IEEE, we need at
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
126 least 6 significant digits for correct results. Using the fraction
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
127 formed by (log(2)*1e6)/(log(10)*1e6) overflows a 32-bit integer as an
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
128 intermediate; perhaps someone can find a better approximation, in the
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
129 mean time, I suspect using doubles won't harm the bootstrap here. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
130
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
131 const double log10_2 = .30102999566398119521;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
132 double log10_b;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
133 const struct real_format *fmt;
|
|
111
|
134 const struct real_format *widefmt;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
135
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
136 char name[64], buf[128];
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
137 int dig, min_10_exp, max_10_exp;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
138 int decimal_dig;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
139 int type_decimal_dig;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
140
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
141 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
142 gcc_assert (fmt->b != 10);
|
|
111
|
143 widefmt = REAL_MODE_FORMAT (TYPE_MODE (long_double_type_node));
|
|
|
144 gcc_assert (widefmt->b != 10);
|
|
|
145 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
|
|
|
146 {
|
|
|
147 tree wtype = FLOATN_NX_TYPE_NODE (i);
|
|
|
148 if (wtype != NULL_TREE)
|
|
|
149 {
|
|
|
150 const struct real_format *wfmt
|
|
|
151 = REAL_MODE_FORMAT (TYPE_MODE (wtype));
|
|
|
152 gcc_assert (wfmt->b != 10);
|
|
|
153 if (wfmt->p > widefmt->p)
|
|
|
154 widefmt = wfmt;
|
|
|
155 }
|
|
|
156 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
157
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
158 /* The radix of the exponent representation. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
159 if (type == float_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
160 builtin_define_with_int_value ("__FLT_RADIX__", fmt->b);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
161 log10_b = log10_2;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
162
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
163 /* The number of radix digits, p, in the floating-point significand. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
164 sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
165 builtin_define_with_int_value (name, fmt->p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
166
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
167 /* The number of decimal digits, q, such that any floating-point number
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
168 with q decimal digits can be rounded into a floating-point number with
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
169 p radix b digits and back again without change to the q decimal digits,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
170
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
171 p log10 b if b is a power of 10
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
172 floor((p - 1) log10 b) otherwise
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
173 */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
174 dig = (fmt->p - 1) * log10_b;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
175 sprintf (name, "__%s_DIG__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
176 builtin_define_with_int_value (name, dig);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
177
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
178 /* The minimum negative int x such that b**(x-1) is a normalized float. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
179 sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
180 sprintf (buf, "(%d)", fmt->emin);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
181 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
182
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
183 /* The minimum negative int x such that 10**x is a normalized float,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
184
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
185 ceil (log10 (b ** (emin - 1)))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
186 = ceil (log10 (b) * (emin - 1))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
187
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
188 Recall that emin is negative, so the integer truncation calculates
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
189 the ceiling, not the floor, in this case. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
190 min_10_exp = (fmt->emin - 1) * log10_b;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
191 sprintf (name, "__%s_MIN_10_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
192 sprintf (buf, "(%d)", min_10_exp);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
193 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
194
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
195 /* The maximum int x such that b**(x-1) is a representable float. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
196 sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
197 builtin_define_with_int_value (name, fmt->emax);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
198
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
199 /* The maximum int x such that 10**x is in the range of representable
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
200 finite floating-point numbers,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
201
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
202 floor (log10((1 - b**-p) * b**emax))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
203 = floor (log10(1 - b**-p) + log10(b**emax))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
204 = floor (log10(1 - b**-p) + log10(b)*emax)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
205
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
206 The safest thing to do here is to just compute this number. But since
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
207 we don't link cc1 with libm, we cannot. We could implement log10 here
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
208 a series expansion, but that seems too much effort because:
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
210 Note that the first term, for all extant p, is a number exceedingly close
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
211 to zero, but slightly negative. Note that the second term is an integer
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
212 scaling an irrational number, and that because of the floor we are only
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
213 interested in its integral portion.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
214
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
215 In order for the first term to have any effect on the integral portion
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
216 of the second term, the second term has to be exceedingly close to an
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
217 integer itself (e.g. 123.000000000001 or something). Getting a result
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
218 that close to an integer requires that the irrational multiplicand have
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
219 a long series of zeros in its expansion, which doesn't occur in the
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220 first 20 digits or so of log10(b).
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
222 Hand-waving aside, crunching all of the sets of constants above by hand
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
223 does not yield a case for which the first term is significant, which
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
224 in the end is all that matters. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
225 max_10_exp = fmt->emax * log10_b;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
226 sprintf (name, "__%s_MAX_10_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
227 builtin_define_with_int_value (name, max_10_exp);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
228
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229 /* The number of decimal digits, n, such that any floating-point number
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
230 can be rounded to n decimal digits and back again without change to
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
231 the value.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
232
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
233 p * log10(b) if b is a power of 10
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
234 ceil(1 + p * log10(b)) otherwise
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
235
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
236 The only macro we care about is this number for the widest supported
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
237 floating type, but we want this value for rendering constants below. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
238 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
239 double d_decimal_dig
|
|
111
|
240 = 1 + (fmt->p < widefmt->p ? widefmt->p : fmt->p) * log10_b;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
241 decimal_dig = d_decimal_dig;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
242 if (decimal_dig < d_decimal_dig)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
243 decimal_dig++;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
244 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
245 /* Similar, for this type rather than long double. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
246 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247 double type_d_decimal_dig = 1 + fmt->p * log10_b;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
248 type_decimal_dig = type_d_decimal_dig;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
249 if (type_decimal_dig < type_d_decimal_dig)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
250 type_decimal_dig++;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
251 }
|
|
111
|
252 /* Define __DECIMAL_DIG__ to the value for long double to be
|
|
|
253 compatible with C99 and C11; see DR#501 and N2108. */
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
254 if (type == long_double_type_node)
|
|
111
|
255 builtin_define_with_int_value ("__DECIMAL_DIG__", type_decimal_dig);
|
|
|
256 sprintf (name, "__%s_DECIMAL_DIG__", name_prefix);
|
|
|
257 builtin_define_with_int_value (name, type_decimal_dig);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
258
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
259 /* Since, for the supported formats, B is always a power of 2, we
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
260 construct the following numbers directly as a hexadecimal
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
261 constants. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
262 get_max_float (fmt, buf, sizeof (buf));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
263
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
264 sprintf (name, "__%s_MAX__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
265 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
266
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
267 /* The minimum normalized positive floating-point number,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
268 b**(emin-1). */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
269 sprintf (name, "__%s_MIN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
270 sprintf (buf, "0x1p%d", fmt->emin - 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
271 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
272
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
273 /* The difference between 1 and the least value greater than 1 that is
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
274 representable in the given floating point type, b**(1-p). */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
275 sprintf (name, "__%s_EPSILON__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
276 if (fmt->pnan < fmt->p)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
277 /* This is an IBM extended double format, so 1.0 + any double is
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
278 representable precisely. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
279 sprintf (buf, "0x1p%d", fmt->emin - fmt->p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
280 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
281 sprintf (buf, "0x1p%d", 1 - fmt->p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
282 builtin_define_with_hex_fp_value (name, type, decimal_dig, buf, fp_suffix, fp_cast);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
283
|
|
111
|
284 /* For C++ std::numeric_limits<T>::denorm_min and C11 *_TRUE_MIN.
|
|
|
285 The minimum denormalized positive floating-point number, b**(emin-p).
|
|
|
286 The minimum normalized positive floating-point number for formats
|
|
|
287 that don't support denormals. */
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
288 sprintf (name, "__%s_DENORM_MIN__", name_prefix);
|
|
111
|
289 sprintf (buf, "0x1p%d", fmt->emin - (fmt->has_denorm ? fmt->p : 1));
|
|
|
290 builtin_define_with_hex_fp_value (name, type, decimal_dig,
|
|
|
291 buf, fp_suffix, fp_cast);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
292
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
293 sprintf (name, "__%s_HAS_DENORM__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
294 builtin_define_with_value (name, fmt->has_denorm ? "1" : "0", 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
296 /* For C++ std::numeric_limits<T>::has_infinity. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
297 sprintf (name, "__%s_HAS_INFINITY__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
298 builtin_define_with_int_value (name,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
299 MODE_HAS_INFINITIES (TYPE_MODE (type)));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
300 /* For C++ std::numeric_limits<T>::has_quiet_NaN. We do not have a
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
301 predicate to distinguish a target that has both quiet and
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
302 signalling NaNs from a target that has only quiet NaNs or only
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
303 signalling NaNs, so we assume that a target that has any kind of
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
304 NaN has quiet NaNs. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
305 sprintf (name, "__%s_HAS_QUIET_NAN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
306 builtin_define_with_int_value (name, MODE_HAS_NANS (TYPE_MODE (type)));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
307
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
308 /* Note whether we have fast FMA. */
|
|
111
|
309 if (mode_has_fma (TYPE_MODE (type)) && fma_suffix != NULL)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
310 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
311 sprintf (name, "__FP_FAST_FMA%s", fma_suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
312 builtin_define_with_int_value (name, 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
313 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
314 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
315
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
316 /* Define __DECx__ constants for TYPE using NAME_PREFIX and SUFFIX. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
317 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
318 builtin_define_decimal_float_constants (const char *name_prefix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
319 const char *suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
320 tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
321 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
322 const struct real_format *fmt;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
323 char name[64], buf[128], *p;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
324 int digits;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
325
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
326 fmt = REAL_MODE_FORMAT (TYPE_MODE (type));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
327
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
328 /* The number of radix digits, p, in the significand. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
329 sprintf (name, "__%s_MANT_DIG__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
330 builtin_define_with_int_value (name, fmt->p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
331
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
332 /* The minimum negative int x such that b**(x-1) is a normalized float. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
333 sprintf (name, "__%s_MIN_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
334 sprintf (buf, "(%d)", fmt->emin);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
335 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
336
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
337 /* The maximum int x such that b**(x-1) is a representable float. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
338 sprintf (name, "__%s_MAX_EXP__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
339 builtin_define_with_int_value (name, fmt->emax);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
340
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
341 /* Compute the minimum representable value. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
342 sprintf (name, "__%s_MIN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
343 sprintf (buf, "1E%d%s", fmt->emin - 1, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
344 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
345
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
346 /* Compute the maximum representable value. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
347 sprintf (name, "__%s_MAX__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
348 p = buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
349 for (digits = fmt->p; digits; digits--)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
350 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
351 *p++ = '9';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
352 if (digits == fmt->p)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
353 *p++ = '.';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
354 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
355 *p = 0;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
356 /* fmt->p plus 1, to account for the decimal point and fmt->emax
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
357 minus 1 because the digits are nines, not 1.0. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
358 sprintf (&buf[fmt->p + 1], "E%d%s", fmt->emax - 1, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
359 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
360
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
361 /* Compute epsilon (the difference between 1 and least value greater
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
362 than 1 representable). */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
363 sprintf (name, "__%s_EPSILON__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
364 sprintf (buf, "1E-%d%s", fmt->p - 1, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
365 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
366
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
367 /* Minimum subnormal positive decimal value. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
368 sprintf (name, "__%s_SUBNORMAL_MIN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
369 p = buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
370 for (digits = fmt->p; digits > 1; digits--)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
371 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
372 *p++ = '0';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373 if (digits == fmt->p)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
374 *p++ = '.';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
375 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
376 *p = 0;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
377 sprintf (&buf[fmt->p], "1E%d%s", fmt->emin - 1, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
378 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
379 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
380
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
381 /* Define fixed-point constants for TYPE using NAME_PREFIX and SUFFIX. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
382
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
383 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
384 builtin_define_fixed_point_constants (const char *name_prefix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
385 const char *suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
386 tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
387 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
388 char name[64], buf[256], *new_buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
389 int i, mod;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
390
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
391 sprintf (name, "__%s_FBIT__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
392 builtin_define_with_int_value (name, TYPE_FBIT (type));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
393
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
394 sprintf (name, "__%s_IBIT__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
395 builtin_define_with_int_value (name, TYPE_IBIT (type));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
396
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
397 /* If there is no suffix, defines are for fixed-point modes.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
398 We just return. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
399 if (strcmp (suffix, "") == 0)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
400 return;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
401
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
402 if (TYPE_UNSIGNED (type))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
403 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
404 sprintf (name, "__%s_MIN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
405 sprintf (buf, "0.0%s", suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
406 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
407 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
408 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
409 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
410 sprintf (name, "__%s_MIN__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
411 if (ALL_ACCUM_MODE_P (TYPE_MODE (type)))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
412 sprintf (buf, "(-0X1P%d%s-0X1P%d%s)", TYPE_IBIT (type) - 1, suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
413 TYPE_IBIT (type) - 1, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
414 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
415 sprintf (buf, "(-0.5%s-0.5%s)", suffix, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
416 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
417 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
418
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
419 sprintf (name, "__%s_MAX__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
420 sprintf (buf, "0X");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
421 new_buf = buf + 2;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
422 mod = (TYPE_FBIT (type) + TYPE_IBIT (type)) % 4;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
423 if (mod)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
424 sprintf (new_buf++, "%x", (1 << mod) - 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
425 for (i = 0; i < (TYPE_FBIT (type) + TYPE_IBIT (type)) / 4; i++)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
426 sprintf (new_buf++, "F");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
427 sprintf (new_buf, "P-%d%s", TYPE_FBIT (type), suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
428 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
429
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
430 sprintf (name, "__%s_EPSILON__", name_prefix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
431 sprintf (buf, "0x1P-%d%s", TYPE_FBIT (type), suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
432 builtin_define_with_value (name, buf, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
433 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
434
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
435 /* Define macros used by <stdint.h>. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
436 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
437 builtin_define_stdint_macros (void)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
438 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
439 builtin_define_type_max ("__INTMAX_MAX__", intmax_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
440 builtin_define_constants ("__INTMAX_C", intmax_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
441 builtin_define_type_max ("__UINTMAX_MAX__", uintmax_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
442 builtin_define_constants ("__UINTMAX_C", uintmax_type_node);
|
|
111
|
443 builtin_define_type_width ("__INTMAX_WIDTH__", intmax_type_node,
|
|
|
444 uintmax_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
445 if (sig_atomic_type_node)
|
|
111
|
446 {
|
|
|
447 builtin_define_type_minmax ("__SIG_ATOMIC_MIN__", "__SIG_ATOMIC_MAX__",
|
|
|
448 sig_atomic_type_node);
|
|
|
449 builtin_define_type_width ("__SIG_ATOMIC_WIDTH__", sig_atomic_type_node,
|
|
|
450 NULL_TREE);
|
|
|
451 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
452 if (int8_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
453 builtin_define_type_max ("__INT8_MAX__", int8_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
454 if (int16_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
455 builtin_define_type_max ("__INT16_MAX__", int16_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
456 if (int32_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
457 builtin_define_type_max ("__INT32_MAX__", int32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
458 if (int64_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
459 builtin_define_type_max ("__INT64_MAX__", int64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
460 if (uint8_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
461 builtin_define_type_max ("__UINT8_MAX__", uint8_type_node);
|
|
111
|
462 if (c_uint16_type_node)
|
|
|
463 builtin_define_type_max ("__UINT16_MAX__", c_uint16_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
464 if (c_uint32_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
465 builtin_define_type_max ("__UINT32_MAX__", c_uint32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
466 if (c_uint64_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
467 builtin_define_type_max ("__UINT64_MAX__", c_uint64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
468 if (int_least8_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
469 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
470 builtin_define_type_max ("__INT_LEAST8_MAX__", int_least8_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
471 builtin_define_constants ("__INT8_C", int_least8_type_node);
|
|
111
|
472 builtin_define_type_width ("__INT_LEAST8_WIDTH__", int_least8_type_node,
|
|
|
473 uint_least8_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
474 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
475 if (int_least16_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
476 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
477 builtin_define_type_max ("__INT_LEAST16_MAX__", int_least16_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
478 builtin_define_constants ("__INT16_C", int_least16_type_node);
|
|
111
|
479 builtin_define_type_width ("__INT_LEAST16_WIDTH__",
|
|
|
480 int_least16_type_node,
|
|
|
481 uint_least16_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
482 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
483 if (int_least32_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
484 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
485 builtin_define_type_max ("__INT_LEAST32_MAX__", int_least32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
486 builtin_define_constants ("__INT32_C", int_least32_type_node);
|
|
111
|
487 builtin_define_type_width ("__INT_LEAST32_WIDTH__",
|
|
|
488 int_least32_type_node,
|
|
|
489 uint_least32_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
490 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
491 if (int_least64_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
492 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
493 builtin_define_type_max ("__INT_LEAST64_MAX__", int_least64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
494 builtin_define_constants ("__INT64_C", int_least64_type_node);
|
|
111
|
495 builtin_define_type_width ("__INT_LEAST64_WIDTH__",
|
|
|
496 int_least64_type_node,
|
|
|
497 uint_least64_type_node);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
498 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
499 if (uint_least8_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
500 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
501 builtin_define_type_max ("__UINT_LEAST8_MAX__", uint_least8_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
502 builtin_define_constants ("__UINT8_C", uint_least8_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
503 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
504 if (uint_least16_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
505 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
506 builtin_define_type_max ("__UINT_LEAST16_MAX__", uint_least16_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
507 builtin_define_constants ("__UINT16_C", uint_least16_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
508 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
509 if (uint_least32_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
510 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
511 builtin_define_type_max ("__UINT_LEAST32_MAX__", uint_least32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
512 builtin_define_constants ("__UINT32_C", uint_least32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
513 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
514 if (uint_least64_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
515 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
516 builtin_define_type_max ("__UINT_LEAST64_MAX__", uint_least64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
517 builtin_define_constants ("__UINT64_C", uint_least64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
518 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
519 if (int_fast8_type_node)
|
|
111
|
520 {
|
|
|
521 builtin_define_type_max ("__INT_FAST8_MAX__", int_fast8_type_node);
|
|
|
522 builtin_define_type_width ("__INT_FAST8_WIDTH__", int_fast8_type_node,
|
|
|
523 uint_fast8_type_node);
|
|
|
524 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
525 if (int_fast16_type_node)
|
|
111
|
526 {
|
|
|
527 builtin_define_type_max ("__INT_FAST16_MAX__", int_fast16_type_node);
|
|
|
528 builtin_define_type_width ("__INT_FAST16_WIDTH__", int_fast16_type_node,
|
|
|
529 uint_fast16_type_node);
|
|
|
530 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
531 if (int_fast32_type_node)
|
|
111
|
532 {
|
|
|
533 builtin_define_type_max ("__INT_FAST32_MAX__", int_fast32_type_node);
|
|
|
534 builtin_define_type_width ("__INT_FAST32_WIDTH__", int_fast32_type_node,
|
|
|
535 uint_fast32_type_node);
|
|
|
536 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
537 if (int_fast64_type_node)
|
|
111
|
538 {
|
|
|
539 builtin_define_type_max ("__INT_FAST64_MAX__", int_fast64_type_node);
|
|
|
540 builtin_define_type_width ("__INT_FAST64_WIDTH__", int_fast64_type_node,
|
|
|
541 uint_fast64_type_node);
|
|
|
542 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
543 if (uint_fast8_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
544 builtin_define_type_max ("__UINT_FAST8_MAX__", uint_fast8_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
545 if (uint_fast16_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
546 builtin_define_type_max ("__UINT_FAST16_MAX__", uint_fast16_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
547 if (uint_fast32_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
548 builtin_define_type_max ("__UINT_FAST32_MAX__", uint_fast32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
549 if (uint_fast64_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
550 builtin_define_type_max ("__UINT_FAST64_MAX__", uint_fast64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
551 if (intptr_type_node)
|
|
111
|
552 {
|
|
|
553 builtin_define_type_max ("__INTPTR_MAX__", intptr_type_node);
|
|
|
554 builtin_define_type_width ("__INTPTR_WIDTH__", intptr_type_node,
|
|
|
555 uintptr_type_node);
|
|
|
556 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
557 if (uintptr_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
558 builtin_define_type_max ("__UINTPTR_MAX__", uintptr_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
559 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
560
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
561 /* Adjust the optimization macros when a #pragma GCC optimization is done to
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
562 reflect the current level. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
563 void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
564 c_cpp_builtins_optimize_pragma (cpp_reader *pfile, tree prev_tree,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
565 tree cur_tree)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
566 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
567 struct cl_optimization *prev = TREE_OPTIMIZATION (prev_tree);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
568 struct cl_optimization *cur = TREE_OPTIMIZATION (cur_tree);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
569 bool prev_fast_math;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
570 bool cur_fast_math;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
571
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
572 /* -undef turns off target-specific built-ins. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
573 if (flag_undef)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
574 return;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
575
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
576 /* Other target-independent built-ins determined by command-line
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
577 options. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
578 if (!prev->x_optimize_size && cur->x_optimize_size)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
579 cpp_define (pfile, "__OPTIMIZE_SIZE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
580 else if (prev->x_optimize_size && !cur->x_optimize_size)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
581 cpp_undef (pfile, "__OPTIMIZE_SIZE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
582
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
583 if (!prev->x_optimize && cur->x_optimize)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
584 cpp_define (pfile, "__OPTIMIZE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
585 else if (prev->x_optimize && !cur->x_optimize)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
586 cpp_undef (pfile, "__OPTIMIZE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
587
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
588 prev_fast_math = fast_math_flags_struct_set_p (prev);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
589 cur_fast_math = fast_math_flags_struct_set_p (cur);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
590 if (!prev_fast_math && cur_fast_math)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
591 cpp_define (pfile, "__FAST_MATH__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
592 else if (prev_fast_math && !cur_fast_math)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
593 cpp_undef (pfile, "__FAST_MATH__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
594
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
595 if (!prev->x_flag_signaling_nans && cur->x_flag_signaling_nans)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
596 cpp_define (pfile, "__SUPPORT_SNAN__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
597 else if (prev->x_flag_signaling_nans && !cur->x_flag_signaling_nans)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
598 cpp_undef (pfile, "__SUPPORT_SNAN__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
599
|
|
111
|
600 if (!prev->x_flag_errno_math && cur->x_flag_errno_math)
|
|
|
601 cpp_undef (pfile, "__NO_MATH_ERRNO__");
|
|
|
602 else if (prev->x_flag_errno_math && !cur->x_flag_errno_math)
|
|
|
603 cpp_define (pfile, "__NO_MATH_ERRNO__");
|
|
|
604
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
605 if (!prev->x_flag_finite_math_only && cur->x_flag_finite_math_only)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
606 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
607 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
608 cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
609 }
|
|
111
|
610 else if (prev->x_flag_finite_math_only && !cur->x_flag_finite_math_only)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
611 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
612 cpp_undef (pfile, "__FINITE_MATH_ONLY__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
613 cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
614 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
615 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
616
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
617
|
|
111
|
618 /* This function will emit cpp macros to indicate the presence of various lock
|
|
|
619 free atomic operations. */
|
|
|
620
|
|
|
621 static void
|
|
|
622 cpp_atomic_builtins (cpp_reader *pfile)
|
|
|
623 {
|
|
|
624 /* Set a flag for each size of object that compare and swap exists for up to
|
|
|
625 a 16 byte object. */
|
|
|
626 #define SWAP_LIMIT 17
|
|
|
627 bool have_swap[SWAP_LIMIT];
|
|
|
628 unsigned int psize;
|
|
|
629
|
|
|
630 /* Clear the map of sizes compare_and swap exists for. */
|
|
|
631 memset (have_swap, 0, sizeof (have_swap));
|
|
|
632
|
|
|
633 /* Tell source code if the compiler makes sync_compare_and_swap
|
|
|
634 builtins available. */
|
|
|
635 #ifndef HAVE_sync_compare_and_swapqi
|
|
|
636 #define HAVE_sync_compare_and_swapqi 0
|
|
|
637 #endif
|
|
|
638 #ifndef HAVE_atomic_compare_and_swapqi
|
|
|
639 #define HAVE_atomic_compare_and_swapqi 0
|
|
|
640 #endif
|
|
|
641
|
|
|
642 if (HAVE_sync_compare_and_swapqi || HAVE_atomic_compare_and_swapqi)
|
|
|
643 {
|
|
|
644 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
|
|
|
645 have_swap[1] = true;
|
|
|
646 }
|
|
|
647
|
|
|
648 #ifndef HAVE_sync_compare_and_swaphi
|
|
|
649 #define HAVE_sync_compare_and_swaphi 0
|
|
|
650 #endif
|
|
|
651 #ifndef HAVE_atomic_compare_and_swaphi
|
|
|
652 #define HAVE_atomic_compare_and_swaphi 0
|
|
|
653 #endif
|
|
|
654 if (HAVE_sync_compare_and_swaphi || HAVE_atomic_compare_and_swaphi)
|
|
|
655 {
|
|
|
656 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
|
|
|
657 have_swap[2] = true;
|
|
|
658 }
|
|
|
659
|
|
|
660 #ifndef HAVE_sync_compare_and_swapsi
|
|
|
661 #define HAVE_sync_compare_and_swapsi 0
|
|
|
662 #endif
|
|
|
663 #ifndef HAVE_atomic_compare_and_swapsi
|
|
|
664 #define HAVE_atomic_compare_and_swapsi 0
|
|
|
665 #endif
|
|
|
666 if (HAVE_sync_compare_and_swapsi || HAVE_atomic_compare_and_swapsi)
|
|
|
667 {
|
|
|
668 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
|
|
|
669 have_swap[4] = true;
|
|
|
670 }
|
|
|
671
|
|
|
672 #ifndef HAVE_sync_compare_and_swapdi
|
|
|
673 #define HAVE_sync_compare_and_swapdi 0
|
|
|
674 #endif
|
|
|
675 #ifndef HAVE_atomic_compare_and_swapdi
|
|
|
676 #define HAVE_atomic_compare_and_swapdi 0
|
|
|
677 #endif
|
|
|
678 if (HAVE_sync_compare_and_swapdi || HAVE_atomic_compare_and_swapdi)
|
|
|
679 {
|
|
|
680 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
|
|
|
681 have_swap[8] = true;
|
|
|
682 }
|
|
|
683
|
|
|
684 #ifndef HAVE_sync_compare_and_swapti
|
|
|
685 #define HAVE_sync_compare_and_swapti 0
|
|
|
686 #endif
|
|
|
687 #ifndef HAVE_atomic_compare_and_swapti
|
|
|
688 #define HAVE_atomic_compare_and_swapti 0
|
|
|
689 #endif
|
|
|
690 if (HAVE_sync_compare_and_swapti || HAVE_atomic_compare_and_swapti)
|
|
|
691 {
|
|
|
692 cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
|
|
|
693 have_swap[16] = true;
|
|
|
694 }
|
|
|
695
|
|
|
696 /* Tell the source code about various types. These map to the C++11 and C11
|
|
|
697 macros where 2 indicates lock-free always, and 1 indicates sometimes
|
|
|
698 lock free. */
|
|
|
699 #define SIZEOF_NODE(T) (tree_to_uhwi (TYPE_SIZE_UNIT (T)))
|
|
|
700 #define SWAP_INDEX(T) ((SIZEOF_NODE (T) < SWAP_LIMIT) ? SIZEOF_NODE (T) : 0)
|
|
|
701 builtin_define_with_int_value ("__GCC_ATOMIC_BOOL_LOCK_FREE",
|
|
|
702 (have_swap[SWAP_INDEX (boolean_type_node)]? 2 : 1));
|
|
|
703 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR_LOCK_FREE",
|
|
|
704 (have_swap[SWAP_INDEX (signed_char_type_node)]? 2 : 1));
|
|
|
705 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR16_T_LOCK_FREE",
|
|
|
706 (have_swap[SWAP_INDEX (char16_type_node)]? 2 : 1));
|
|
|
707 builtin_define_with_int_value ("__GCC_ATOMIC_CHAR32_T_LOCK_FREE",
|
|
|
708 (have_swap[SWAP_INDEX (char32_type_node)]? 2 : 1));
|
|
|
709 builtin_define_with_int_value ("__GCC_ATOMIC_WCHAR_T_LOCK_FREE",
|
|
|
710 (have_swap[SWAP_INDEX (wchar_type_node)]? 2 : 1));
|
|
|
711 builtin_define_with_int_value ("__GCC_ATOMIC_SHORT_LOCK_FREE",
|
|
|
712 (have_swap[SWAP_INDEX (short_integer_type_node)]? 2 : 1));
|
|
|
713 builtin_define_with_int_value ("__GCC_ATOMIC_INT_LOCK_FREE",
|
|
|
714 (have_swap[SWAP_INDEX (integer_type_node)]? 2 : 1));
|
|
|
715 builtin_define_with_int_value ("__GCC_ATOMIC_LONG_LOCK_FREE",
|
|
|
716 (have_swap[SWAP_INDEX (long_integer_type_node)]? 2 : 1));
|
|
|
717 builtin_define_with_int_value ("__GCC_ATOMIC_LLONG_LOCK_FREE",
|
|
|
718 (have_swap[SWAP_INDEX (long_long_integer_type_node)]? 2 : 1));
|
|
|
719
|
|
|
720 /* If we're dealing with a "set" value that doesn't exactly correspond
|
|
|
721 to a boolean truth value, let the library work around that. */
|
|
|
722 builtin_define_with_int_value ("__GCC_ATOMIC_TEST_AND_SET_TRUEVAL",
|
|
|
723 targetm.atomic_test_and_set_trueval);
|
|
|
724
|
|
|
725 /* ptr_type_node can't be used here since ptr_mode is only set when
|
|
|
726 toplev calls backend_init which is not done with -E or pch. */
|
|
|
727 psize = POINTER_SIZE_UNITS;
|
|
|
728 if (psize >= SWAP_LIMIT)
|
|
|
729 psize = 0;
|
|
|
730 builtin_define_with_int_value ("__GCC_ATOMIC_POINTER_LOCK_FREE",
|
|
|
731 (have_swap[psize]? 2 : 1));
|
|
|
732 }
|
|
|
733
|
|
|
734 /* Return TRUE if the implicit excess precision in which the back-end will
|
|
|
735 compute floating-point calculations is not more than the explicit
|
|
|
736 excess precision that the front-end will apply under
|
|
|
737 -fexcess-precision=[standard|fast].
|
|
|
738
|
|
|
739 More intuitively, return TRUE if the excess precision proposed by the
|
|
|
740 front-end is the excess precision that will actually be used. */
|
|
|
741
|
|
|
742 static bool
|
|
|
743 c_cpp_flt_eval_method_iec_559 (void)
|
|
|
744 {
|
|
|
745 enum excess_precision_type front_end_ept
|
|
|
746 = (flag_excess_precision_cmdline == EXCESS_PRECISION_STANDARD
|
|
|
747 ? EXCESS_PRECISION_TYPE_STANDARD
|
|
|
748 : EXCESS_PRECISION_TYPE_FAST);
|
|
|
749
|
|
|
750 enum flt_eval_method back_end
|
|
|
751 = targetm.c.excess_precision (EXCESS_PRECISION_TYPE_IMPLICIT);
|
|
|
752
|
|
|
753 enum flt_eval_method front_end
|
|
|
754 = targetm.c.excess_precision (front_end_ept);
|
|
|
755
|
|
|
756 return excess_precision_mode_join (front_end, back_end) == front_end;
|
|
|
757 }
|
|
|
758
|
|
|
759 /* Return the value for __GCC_IEC_559. */
|
|
|
760 static int
|
|
|
761 cpp_iec_559_value (void)
|
|
|
762 {
|
|
|
763 /* The default is support for IEEE 754-2008. */
|
|
|
764 int ret = 2;
|
|
|
765
|
|
|
766 /* float and double must be binary32 and binary64. If they are but
|
|
|
767 with reversed NaN convention, at most IEEE 754-1985 is
|
|
|
768 supported. */
|
|
|
769 const struct real_format *ffmt
|
|
|
770 = REAL_MODE_FORMAT (TYPE_MODE (float_type_node));
|
|
|
771 const struct real_format *dfmt
|
|
|
772 = REAL_MODE_FORMAT (TYPE_MODE (double_type_node));
|
|
|
773 if (!ffmt->qnan_msb_set || !dfmt->qnan_msb_set)
|
|
|
774 ret = 1;
|
|
|
775 if (ffmt->b != 2
|
|
|
776 || ffmt->p != 24
|
|
|
777 || ffmt->pnan != 24
|
|
|
778 || ffmt->emin != -125
|
|
|
779 || ffmt->emax != 128
|
|
|
780 || ffmt->signbit_rw != 31
|
|
|
781 || ffmt->round_towards_zero
|
|
|
782 || !ffmt->has_sign_dependent_rounding
|
|
|
783 || !ffmt->has_nans
|
|
|
784 || !ffmt->has_inf
|
|
|
785 || !ffmt->has_denorm
|
|
|
786 || !ffmt->has_signed_zero
|
|
|
787 || dfmt->b != 2
|
|
|
788 || dfmt->p != 53
|
|
|
789 || dfmt->pnan != 53
|
|
|
790 || dfmt->emin != -1021
|
|
|
791 || dfmt->emax != 1024
|
|
|
792 || dfmt->signbit_rw != 63
|
|
|
793 || dfmt->round_towards_zero
|
|
|
794 || !dfmt->has_sign_dependent_rounding
|
|
|
795 || !dfmt->has_nans
|
|
|
796 || !dfmt->has_inf
|
|
|
797 || !dfmt->has_denorm
|
|
|
798 || !dfmt->has_signed_zero)
|
|
|
799 ret = 0;
|
|
|
800
|
|
|
801 /* In strict C standards conformance mode, consider a back-end providing
|
|
|
802 more implicit excess precision than the explicit excess precision
|
|
|
803 the front-end options would require to mean a lack of IEEE 754
|
|
|
804 support. For C++, and outside strict conformance mode, do not consider
|
|
|
805 this to mean a lack of IEEE 754 support. */
|
|
|
806
|
|
|
807 if (flag_iso
|
|
|
808 && !c_dialect_cxx ()
|
|
|
809 && !c_cpp_flt_eval_method_iec_559 ())
|
|
|
810 ret = 0;
|
|
|
811
|
|
|
812 if (flag_iso
|
|
|
813 && !c_dialect_cxx ()
|
|
|
814 && flag_fp_contract_mode == FP_CONTRACT_FAST)
|
|
|
815 ret = 0;
|
|
|
816
|
|
|
817 /* Various options are contrary to IEEE 754 semantics. */
|
|
|
818 if (flag_unsafe_math_optimizations
|
|
|
819 || flag_associative_math
|
|
|
820 || flag_reciprocal_math
|
|
|
821 || flag_finite_math_only
|
|
|
822 || !flag_signed_zeros
|
|
|
823 || flag_single_precision_constant)
|
|
|
824 ret = 0;
|
|
|
825
|
|
|
826 /* If the target does not support IEEE 754 exceptions and rounding
|
|
|
827 modes, consider IEEE 754 support to be absent. */
|
|
|
828 if (!targetm.float_exceptions_rounding_supported_p ())
|
|
|
829 ret = 0;
|
|
|
830
|
|
|
831 return ret;
|
|
|
832 }
|
|
|
833
|
|
|
834 /* Return the value for __GCC_IEC_559_COMPLEX. */
|
|
|
835 static int
|
|
|
836 cpp_iec_559_complex_value (void)
|
|
|
837 {
|
|
|
838 /* The value is no bigger than that of __GCC_IEC_559. */
|
|
|
839 int ret = cpp_iec_559_value ();
|
|
|
840
|
|
|
841 /* Some options are contrary to the required default state of the
|
|
|
842 CX_LIMITED_RANGE pragma. */
|
|
|
843 if (flag_complex_method != 2)
|
|
|
844 ret = 0;
|
|
|
845
|
|
|
846 return ret;
|
|
|
847 }
|
|
|
848
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
849 /* Hook that registers front end and target-specific built-ins. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
850 void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
851 c_cpp_builtins (cpp_reader *pfile)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
852 {
|
|
111
|
853 int i;
|
|
|
854
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
855 /* -undef turns off target-specific built-ins. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
856 if (flag_undef)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
857 return;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
858
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
859 define_language_independent_builtin_macros (pfile);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
860
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
861 if (c_dialect_cxx ())
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
862 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
863 int major;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
864 parse_basever (&major, NULL, NULL);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
865 cpp_define_formatted (pfile, "__GNUG__=%d", major);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
866 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
867
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
868 /* For stddef.h. They require macros defined in c-common.c. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
869 c_stddef_cpp_builtins ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
870
|
|
111
|
871 /* Set include test macros for all C/C++ (not for just C++11 etc.)
|
|
|
872 The builtins __has_include__ and __has_include_next__ are defined
|
|
|
873 in libcpp. */
|
|
|
874 cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
|
|
|
875 cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
|
|
|
876
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
877 if (c_dialect_cxx ())
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
878 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
879 if (flag_weak && SUPPORTS_ONE_ONLY)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
880 cpp_define (pfile, "__GXX_WEAK__=1");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
881 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
882 cpp_define (pfile, "__GXX_WEAK__=0");
|
|
111
|
883
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
884 if (warn_deprecated)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
885 cpp_define (pfile, "__DEPRECATED");
|
|
111
|
886
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
887 if (flag_rtti)
|
|
111
|
888 {
|
|
|
889 cpp_define (pfile, "__GXX_RTTI");
|
|
|
890 cpp_define (pfile, "__cpp_rtti=199711");
|
|
|
891 }
|
|
|
892
|
|
|
893 if (cxx_dialect >= cxx11)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
894 cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
|
|
111
|
895
|
|
|
896 /* Binary literals have been allowed in g++ before C++11
|
|
|
897 and were standardized for C++14. */
|
|
|
898 if (!pedantic || cxx_dialect > cxx11)
|
|
|
899 cpp_define (pfile, "__cpp_binary_literals=201304");
|
|
|
900
|
|
|
901 /* Similarly for hexadecimal floating point literals and C++17. */
|
|
|
902 if (!pedantic || cpp_get_options (parse_in)->extended_numbers)
|
|
|
903 cpp_define (pfile, "__cpp_hex_float=201603");
|
|
|
904
|
|
|
905 /* Arrays of runtime bound were removed from C++14, but we still
|
|
|
906 support GNU VLAs. Let's define this macro to a low number
|
|
|
907 (corresponding to the initial test release of GNU C++) if we won't
|
|
|
908 complain about use of VLAs. */
|
|
|
909 if (c_dialect_cxx ()
|
|
|
910 && (pedantic ? warn_vla == 0 : warn_vla <= 0))
|
|
|
911 cpp_define (pfile, "__cpp_runtime_arrays=198712");
|
|
|
912
|
|
|
913 if (cxx_dialect >= cxx11)
|
|
|
914 {
|
|
|
915 /* Set feature test macros for C++11. */
|
|
|
916 if (cxx_dialect <= cxx14)
|
|
|
917 cpp_define (pfile, "__cpp_unicode_characters=200704");
|
|
|
918 cpp_define (pfile, "__cpp_raw_strings=200710");
|
|
|
919 cpp_define (pfile, "__cpp_unicode_literals=200710");
|
|
|
920 cpp_define (pfile, "__cpp_user_defined_literals=200809");
|
|
|
921 cpp_define (pfile, "__cpp_lambdas=200907");
|
|
|
922 if (cxx_dialect == cxx11)
|
|
|
923 cpp_define (pfile, "__cpp_constexpr=200704");
|
|
|
924 if (cxx_dialect <= cxx14)
|
|
|
925 cpp_define (pfile, "__cpp_range_based_for=200907");
|
|
|
926 if (cxx_dialect <= cxx14)
|
|
|
927 cpp_define (pfile, "__cpp_static_assert=200410");
|
|
|
928 cpp_define (pfile, "__cpp_decltype=200707");
|
|
|
929 cpp_define (pfile, "__cpp_attributes=200809");
|
|
|
930 cpp_define (pfile, "__cpp_rvalue_reference=200610");
|
|
|
931 cpp_define (pfile, "__cpp_rvalue_references=200610");
|
|
|
932 cpp_define (pfile, "__cpp_variadic_templates=200704");
|
|
|
933 cpp_define (pfile, "__cpp_initializer_lists=200806");
|
|
|
934 cpp_define (pfile, "__cpp_delegating_constructors=200604");
|
|
|
935 cpp_define (pfile, "__cpp_nsdmi=200809");
|
|
|
936 if (!flag_new_inheriting_ctors)
|
|
|
937 cpp_define (pfile, "__cpp_inheriting_constructors=200802");
|
|
|
938 else
|
|
|
939 cpp_define (pfile, "__cpp_inheriting_constructors=201511");
|
|
|
940 cpp_define (pfile, "__cpp_ref_qualifiers=200710");
|
|
|
941 cpp_define (pfile, "__cpp_alias_templates=200704");
|
|
|
942 }
|
|
|
943 if (cxx_dialect > cxx11)
|
|
|
944 {
|
|
|
945 /* Set feature test macros for C++14. */
|
|
|
946 cpp_define (pfile, "__cpp_return_type_deduction=201304");
|
|
|
947 cpp_define (pfile, "__cpp_init_captures=201304");
|
|
|
948 cpp_define (pfile, "__cpp_generic_lambdas=201304");
|
|
|
949 if (cxx_dialect <= cxx14)
|
|
|
950 cpp_define (pfile, "__cpp_constexpr=201304");
|
|
|
951 cpp_define (pfile, "__cpp_decltype_auto=201304");
|
|
|
952 cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
|
|
|
953 cpp_define (pfile, "__cpp_variable_templates=201304");
|
|
|
954 cpp_define (pfile, "__cpp_digit_separators=201309");
|
|
|
955 }
|
|
|
956 if (cxx_dialect > cxx14)
|
|
|
957 {
|
|
|
958 /* Set feature test macros for C++1z. */
|
|
|
959 cpp_define (pfile, "__cpp_unicode_characters=201411");
|
|
|
960 cpp_define (pfile, "__cpp_static_assert=201411");
|
|
|
961 cpp_define (pfile, "__cpp_namespace_attributes=201411");
|
|
|
962 cpp_define (pfile, "__cpp_enumerator_attributes=201411");
|
|
|
963 cpp_define (pfile, "__cpp_nested_namespace_definitions=201411");
|
|
|
964 cpp_define (pfile, "__cpp_fold_expressions=201603");
|
|
|
965 cpp_define (pfile, "__cpp_nontype_template_args=201411");
|
|
|
966 cpp_define (pfile, "__cpp_range_based_for=201603");
|
|
|
967 cpp_define (pfile, "__cpp_constexpr=201603");
|
|
|
968 cpp_define (pfile, "__cpp_if_constexpr=201606");
|
|
|
969 cpp_define (pfile, "__cpp_capture_star_this=201603");
|
|
|
970 cpp_define (pfile, "__cpp_inline_variables=201606");
|
|
|
971 cpp_define (pfile, "__cpp_aggregate_bases=201603");
|
|
131
|
972 cpp_define (pfile, "__cpp_deduction_guides=201703");
|
|
111
|
973 cpp_define (pfile, "__cpp_noexcept_function_type=201510");
|
|
|
974 cpp_define (pfile, "__cpp_template_auto=201606");
|
|
|
975 cpp_define (pfile, "__cpp_structured_bindings=201606");
|
|
|
976 cpp_define (pfile, "__cpp_variadic_using=201611");
|
|
|
977 }
|
|
|
978 if (flag_concepts)
|
|
|
979 cpp_define (pfile, "__cpp_concepts=201507");
|
|
|
980 if (flag_tm)
|
|
|
981 /* Use a value smaller than the 201505 specified in
|
|
|
982 the TS, since we don't yet support atomic_cancel. */
|
|
131
|
983 cpp_define (pfile, "__cpp_transactional_memory=201500");
|
|
111
|
984 if (flag_sized_deallocation)
|
|
|
985 cpp_define (pfile, "__cpp_sized_deallocation=201309");
|
|
|
986 if (aligned_new_threshold)
|
|
|
987 {
|
|
|
988 cpp_define (pfile, "__cpp_aligned_new=201606");
|
|
|
989 cpp_define_formatted (pfile, "__STDCPP_DEFAULT_NEW_ALIGNMENT__=%d",
|
|
|
990 aligned_new_threshold);
|
|
|
991 }
|
|
|
992 if (flag_new_ttp)
|
|
|
993 cpp_define (pfile, "__cpp_template_template_args=201611");
|
|
|
994 if (flag_threadsafe_statics)
|
|
|
995 cpp_define (pfile, "__cpp_threadsafe_static_init=200806");
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
996 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
997 /* Note that we define this for C as well, so that we know if
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
998 __attribute__((cleanup)) will interface with EH. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
999 if (flag_exceptions)
|
|
111
|
1000 {
|
|
|
1001 cpp_define (pfile, "__EXCEPTIONS");
|
|
|
1002 if (c_dialect_cxx ())
|
|
|
1003 cpp_define (pfile, "__cpp_exceptions=199711");
|
|
|
1004 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1005
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1006 /* Represents the C++ ABI version, always defined so it can be used while
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1007 preprocessing C and assembler. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1008 if (flag_abi_version == 0)
|
|
111
|
1009 /* We should have set this to something real in c_common_post_options. */
|
|
|
1010 gcc_unreachable ();
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1011 else if (flag_abi_version == 1)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1012 /* Due to a historical accident, this version had the value
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1013 "102". */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1014 builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1015 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1016 /* Newer versions have values 1002, 1003, .... */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1017 builtin_define_with_int_value ("__GXX_ABI_VERSION",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1018 1000 + flag_abi_version);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1019
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1020 /* libgcc needs to know this. */
|
|
111
|
1021 if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1022 cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1023
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1024 /* limits.h and stdint.h need to know these. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1025 builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1026 builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1027 builtin_define_type_max ("__INT_MAX__", integer_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1028 builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1029 builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1030 builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1031 underlying_wchar_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1032 builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1033 builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1034 builtin_define_type_max ("__SIZE_MAX__", size_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1035
|
|
111
|
1036 /* These are needed for TS 18661-1. */
|
|
|
1037 builtin_define_type_width ("__SCHAR_WIDTH__", signed_char_type_node,
|
|
|
1038 unsigned_char_type_node);
|
|
|
1039 builtin_define_type_width ("__SHRT_WIDTH__", short_integer_type_node,
|
|
|
1040 short_unsigned_type_node);
|
|
|
1041 builtin_define_type_width ("__INT_WIDTH__", integer_type_node,
|
|
|
1042 unsigned_type_node);
|
|
|
1043 builtin_define_type_width ("__LONG_WIDTH__", long_integer_type_node,
|
|
|
1044 long_unsigned_type_node);
|
|
|
1045 builtin_define_type_width ("__LONG_LONG_WIDTH__",
|
|
|
1046 long_long_integer_type_node,
|
|
|
1047 long_long_unsigned_type_node);
|
|
|
1048 builtin_define_type_width ("__WCHAR_WIDTH__", underlying_wchar_type_node,
|
|
|
1049 NULL_TREE);
|
|
|
1050 builtin_define_type_width ("__WINT_WIDTH__", wint_type_node, NULL_TREE);
|
|
|
1051 builtin_define_type_width ("__PTRDIFF_WIDTH__", ptrdiff_type_node, NULL_TREE);
|
|
|
1052 builtin_define_type_width ("__SIZE_WIDTH__", size_type_node, NULL_TREE);
|
|
|
1053
|
|
|
1054 if (c_dialect_cxx ())
|
|
|
1055 for (i = 0; i < NUM_INT_N_ENTS; i ++)
|
|
|
1056 if (int_n_enabled_p[i])
|
|
|
1057 {
|
|
|
1058 char buf[35+20+20];
|
|
|
1059
|
|
|
1060 /* These are used to configure the C++ library. */
|
|
|
1061
|
|
|
1062 if (!flag_iso || int_n_data[i].bitsize == POINTER_SIZE)
|
|
|
1063 {
|
|
|
1064 sprintf (buf, "__GLIBCXX_TYPE_INT_N_%d=__int%d", i, int_n_data[i].bitsize);
|
|
|
1065 cpp_define (parse_in, buf);
|
|
|
1066
|
|
|
1067 sprintf (buf, "__GLIBCXX_BITSIZE_INT_N_%d=%d", i, int_n_data[i].bitsize);
|
|
|
1068 cpp_define (parse_in, buf);
|
|
|
1069 }
|
|
|
1070 }
|
|
|
1071
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1072 /* stdint.h and the testsuite need to know these. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1073 builtin_define_stdint_macros ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1074
|
|
111
|
1075 /* Provide information for library headers to determine whether to
|
|
|
1076 define macros such as __STDC_IEC_559__ and
|
|
|
1077 __STDC_IEC_559_COMPLEX__. */
|
|
|
1078 builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
|
|
|
1079 builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
|
|
|
1080 cpp_iec_559_complex_value ());
|
|
|
1081
|
|
|
1082 /* float.h needs these to correctly set FLT_EVAL_METHOD
|
|
|
1083
|
|
|
1084 We define two values:
|
|
|
1085
|
|
|
1086 __FLT_EVAL_METHOD__
|
|
|
1087 Which, depending on the value given for
|
|
|
1088 -fpermitted-flt-eval-methods, may be limited to only those values
|
|
|
1089 for FLT_EVAL_METHOD defined in C99/C11.
|
|
|
1090
|
|
|
1091 __FLT_EVAL_METHOD_TS_18661_3__
|
|
|
1092 Which always permits the values for FLT_EVAL_METHOD defined in
|
|
|
1093 ISO/IEC TS 18661-3. */
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1094 builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
|
|
111
|
1095 c_flt_eval_method (true));
|
|
|
1096 builtin_define_with_int_value ("__FLT_EVAL_METHOD_TS_18661_3__",
|
|
|
1097 c_flt_eval_method (false));
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1098
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1099 /* And decfloat.h needs this. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1100 builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1101 TARGET_DEC_EVAL_METHOD);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1102
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1103 builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1104 /* Cast the double precision constants. This is needed when single
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1105 precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1106 is used. The correct result is computed by the compiler when using
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1107 macros that include a cast. We use a different cast for C++ to avoid
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1108 problems with -Wold-style-cast. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1109 builtin_define_float_constants ("DBL", "L",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1110 (c_dialect_cxx ()
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1111 ? "double(%s)"
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1112 : "((double)%s)"),
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1113 "", double_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1114 builtin_define_float_constants ("LDBL", "L", "%s", "L",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1115 long_double_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1116
|
|
111
|
1117 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
|
|
|
1118 {
|
|
|
1119 if (FLOATN_NX_TYPE_NODE (i) == NULL_TREE)
|
|
|
1120 continue;
|
|
|
1121 char prefix[20], csuffix[20];
|
|
|
1122 sprintf (prefix, "FLT%d%s", floatn_nx_types[i].n,
|
|
|
1123 floatn_nx_types[i].extended ? "X" : "");
|
|
|
1124 sprintf (csuffix, "F%d%s", floatn_nx_types[i].n,
|
|
|
1125 floatn_nx_types[i].extended ? "x" : "");
|
|
131
|
1126 builtin_define_float_constants (prefix, ggc_strdup (csuffix), "%s",
|
|
|
1127 csuffix, FLOATN_NX_TYPE_NODE (i));
|
|
111
|
1128 }
|
|
|
1129
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1130 /* For decfloat.h. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1131 builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1132 builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1133 builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1134
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1135 /* For fixed-point fibt, ibit, max, min, and epsilon. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1136 if (targetm.fixed_point_supported_p ())
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1137 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1138 builtin_define_fixed_point_constants ("SFRACT", "HR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1139 short_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1140 builtin_define_fixed_point_constants ("USFRACT", "UHR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1141 unsigned_short_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1142 builtin_define_fixed_point_constants ("FRACT", "R",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1143 fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1144 builtin_define_fixed_point_constants ("UFRACT", "UR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1145 unsigned_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1146 builtin_define_fixed_point_constants ("LFRACT", "LR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1147 long_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1148 builtin_define_fixed_point_constants ("ULFRACT", "ULR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1149 unsigned_long_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1150 builtin_define_fixed_point_constants ("LLFRACT", "LLR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1151 long_long_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1152 builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1153 unsigned_long_long_fract_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1154 builtin_define_fixed_point_constants ("SACCUM", "HK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1155 short_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1156 builtin_define_fixed_point_constants ("USACCUM", "UHK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1157 unsigned_short_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1158 builtin_define_fixed_point_constants ("ACCUM", "K",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1159 accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1160 builtin_define_fixed_point_constants ("UACCUM", "UK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1161 unsigned_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1162 builtin_define_fixed_point_constants ("LACCUM", "LK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1163 long_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1164 builtin_define_fixed_point_constants ("ULACCUM", "ULK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1165 unsigned_long_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1166 builtin_define_fixed_point_constants ("LLACCUM", "LLK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1167 long_long_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1168 builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1169 unsigned_long_long_accum_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1170
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1171 builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1172 builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1173 builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1174 builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1175 builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1176 builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1177 builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1178 builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1179 builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1180 builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1181 builtin_define_fixed_point_constants ("HA", "", ha_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1182 builtin_define_fixed_point_constants ("SA", "", sa_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1183 builtin_define_fixed_point_constants ("DA", "", da_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1184 builtin_define_fixed_point_constants ("TA", "", ta_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1185 builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1186 builtin_define_fixed_point_constants ("USA", "", usa_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1187 builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1188 builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1189 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1190
|
|
111
|
1191 /* For libgcc-internal use only. */
|
|
|
1192 if (flag_building_libgcc)
|
|
|
1193 {
|
|
|
1194 /* Properties of floating-point modes for libgcc2.c. */
|
|
|
1195 opt_scalar_float_mode mode_iter;
|
|
|
1196 FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_FLOAT)
|
|
|
1197 {
|
|
|
1198 scalar_float_mode mode = mode_iter.require ();
|
|
|
1199 const char *name = GET_MODE_NAME (mode);
|
|
|
1200 char *macro_name
|
|
|
1201 = (char *) alloca (strlen (name)
|
|
|
1202 + sizeof ("__LIBGCC__MANT_DIG__"));
|
|
|
1203 sprintf (macro_name, "__LIBGCC_%s_MANT_DIG__", name);
|
|
|
1204 builtin_define_with_int_value (macro_name,
|
|
|
1205 REAL_MODE_FORMAT (mode)->p);
|
|
|
1206 if (!targetm.scalar_mode_supported_p (mode)
|
|
|
1207 || !targetm.libgcc_floating_mode_supported_p (mode))
|
|
|
1208 continue;
|
|
|
1209 macro_name = (char *) alloca (strlen (name)
|
|
|
1210 + sizeof ("__LIBGCC_HAS__MODE__"));
|
|
|
1211 sprintf (macro_name, "__LIBGCC_HAS_%s_MODE__", name);
|
|
|
1212 cpp_define (pfile, macro_name);
|
|
|
1213 macro_name = (char *) alloca (strlen (name)
|
|
|
1214 + sizeof ("__LIBGCC__FUNC_EXT__"));
|
|
|
1215 sprintf (macro_name, "__LIBGCC_%s_FUNC_EXT__", name);
|
|
|
1216 char suffix[20] = "";
|
|
|
1217 if (mode == TYPE_MODE (double_type_node))
|
|
|
1218 ; /* Empty suffix correct. */
|
|
|
1219 else if (mode == TYPE_MODE (float_type_node))
|
|
|
1220 suffix[0] = 'f';
|
|
|
1221 else if (mode == TYPE_MODE (long_double_type_node))
|
|
|
1222 suffix[0] = 'l';
|
|
|
1223 else
|
|
|
1224 {
|
|
|
1225 bool found_suffix = false;
|
|
|
1226 for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
|
|
|
1227 if (FLOATN_NX_TYPE_NODE (i) != NULL_TREE
|
|
|
1228 && mode == TYPE_MODE (FLOATN_NX_TYPE_NODE (i)))
|
|
|
1229 {
|
|
|
1230 sprintf (suffix, "f%d%s", floatn_nx_types[i].n,
|
|
|
1231 floatn_nx_types[i].extended ? "x" : "");
|
|
|
1232 found_suffix = true;
|
|
|
1233 break;
|
|
|
1234 }
|
|
|
1235 gcc_assert (found_suffix);
|
|
|
1236 }
|
|
|
1237 builtin_define_with_value (macro_name, suffix, 0);
|
|
|
1238
|
|
|
1239 /* The way __LIBGCC_*_EXCESS_PRECISION__ is used is about
|
|
|
1240 eliminating excess precision from results assigned to
|
|
|
1241 variables - meaning it should be about the implicit excess
|
|
|
1242 precision only. */
|
|
|
1243 bool excess_precision = false;
|
|
|
1244 machine_mode float16_type_mode = (float16_type_node
|
|
|
1245 ? TYPE_MODE (float16_type_node)
|
|
|
1246 : VOIDmode);
|
|
|
1247 switch (targetm.c.excess_precision
|
|
|
1248 (EXCESS_PRECISION_TYPE_IMPLICIT))
|
|
|
1249 {
|
|
|
1250 case FLT_EVAL_METHOD_UNPREDICTABLE:
|
|
|
1251 case FLT_EVAL_METHOD_PROMOTE_TO_LONG_DOUBLE:
|
|
|
1252 excess_precision = (mode == float16_type_mode
|
|
|
1253 || mode == TYPE_MODE (float_type_node)
|
|
|
1254 || mode == TYPE_MODE (double_type_node));
|
|
|
1255 break;
|
|
|
1256
|
|
|
1257 case FLT_EVAL_METHOD_PROMOTE_TO_DOUBLE:
|
|
|
1258 excess_precision = (mode == float16_type_mode
|
|
|
1259 || mode == TYPE_MODE (float_type_node));
|
|
|
1260 break;
|
|
|
1261 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT:
|
|
|
1262 excess_precision = mode == float16_type_mode;
|
|
|
1263 break;
|
|
|
1264 case FLT_EVAL_METHOD_PROMOTE_TO_FLOAT16:
|
|
|
1265 excess_precision = false;
|
|
|
1266 break;
|
|
|
1267 default:
|
|
|
1268 gcc_unreachable ();
|
|
|
1269 }
|
|
|
1270 macro_name = (char *) alloca (strlen (name)
|
|
|
1271 + sizeof ("__LIBGCC__EXCESS_"
|
|
|
1272 "PRECISION__"));
|
|
|
1273 sprintf (macro_name, "__LIBGCC_%s_EXCESS_PRECISION__", name);
|
|
|
1274 builtin_define_with_int_value (macro_name, excess_precision);
|
|
|
1275 }
|
|
|
1276
|
|
|
1277 /* For libgcc crtstuff.c and libgcc2.c. */
|
|
|
1278 builtin_define_with_int_value ("__LIBGCC_EH_TABLES_CAN_BE_READ_ONLY__",
|
|
|
1279 EH_TABLES_CAN_BE_READ_ONLY);
|
|
|
1280 #ifdef EH_FRAME_SECTION_NAME
|
|
|
1281 builtin_define_with_value ("__LIBGCC_EH_FRAME_SECTION_NAME__",
|
|
|
1282 EH_FRAME_SECTION_NAME, 1);
|
|
|
1283 #endif
|
|
|
1284 #ifdef CTORS_SECTION_ASM_OP
|
|
|
1285 builtin_define_with_value ("__LIBGCC_CTORS_SECTION_ASM_OP__",
|
|
|
1286 CTORS_SECTION_ASM_OP, 1);
|
|
|
1287 #endif
|
|
|
1288 #ifdef DTORS_SECTION_ASM_OP
|
|
|
1289 builtin_define_with_value ("__LIBGCC_DTORS_SECTION_ASM_OP__",
|
|
|
1290 DTORS_SECTION_ASM_OP, 1);
|
|
|
1291 #endif
|
|
|
1292 #ifdef TEXT_SECTION_ASM_OP
|
|
|
1293 builtin_define_with_value ("__LIBGCC_TEXT_SECTION_ASM_OP__",
|
|
|
1294 TEXT_SECTION_ASM_OP, 1);
|
|
|
1295 #endif
|
|
|
1296 #ifdef INIT_SECTION_ASM_OP
|
|
|
1297 builtin_define_with_value ("__LIBGCC_INIT_SECTION_ASM_OP__",
|
|
|
1298 INIT_SECTION_ASM_OP, 1);
|
|
|
1299 #endif
|
|
|
1300 #ifdef INIT_ARRAY_SECTION_ASM_OP
|
|
|
1301 /* Despite the name of this target macro, the expansion is not
|
|
|
1302 actually used, and may be empty rather than a string
|
|
|
1303 constant. */
|
|
|
1304 cpp_define (pfile, "__LIBGCC_INIT_ARRAY_SECTION_ASM_OP__");
|
|
|
1305 #endif
|
|
|
1306
|
|
|
1307 /* For libgcc enable-execute-stack.c. */
|
|
|
1308 builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
|
|
|
1309 TRAMPOLINE_SIZE);
|
|
|
1310
|
|
|
1311 /* For libgcc generic-morestack.c and unwinder code. */
|
|
|
1312 if (STACK_GROWS_DOWNWARD)
|
|
|
1313 cpp_define (pfile, "__LIBGCC_STACK_GROWS_DOWNWARD__");
|
|
|
1314
|
|
|
1315 /* For libgcc unwinder code. */
|
|
|
1316 #ifdef DONT_USE_BUILTIN_SETJMP
|
|
|
1317 cpp_define (pfile, "__LIBGCC_DONT_USE_BUILTIN_SETJMP__");
|
|
|
1318 #endif
|
|
|
1319 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
|
|
|
1320 builtin_define_with_int_value ("__LIBGCC_DWARF_ALT_FRAME_RETURN_COLUMN__",
|
|
|
1321 DWARF_ALT_FRAME_RETURN_COLUMN);
|
|
|
1322 #endif
|
|
|
1323 builtin_define_with_int_value ("__LIBGCC_DWARF_FRAME_REGISTERS__",
|
|
|
1324 DWARF_FRAME_REGISTERS);
|
|
|
1325 #ifdef EH_RETURN_STACKADJ_RTX
|
|
|
1326 cpp_define (pfile, "__LIBGCC_EH_RETURN_STACKADJ_RTX__");
|
|
|
1327 #endif
|
|
|
1328 #ifdef JMP_BUF_SIZE
|
|
|
1329 builtin_define_with_int_value ("__LIBGCC_JMP_BUF_SIZE__",
|
|
|
1330 JMP_BUF_SIZE);
|
|
|
1331 #endif
|
|
|
1332 builtin_define_with_int_value ("__LIBGCC_STACK_POINTER_REGNUM__",
|
|
|
1333 STACK_POINTER_REGNUM);
|
|
|
1334
|
|
|
1335 /* For libgcov. */
|
|
|
1336 builtin_define_with_int_value ("__LIBGCC_VTABLE_USES_DESCRIPTORS__",
|
|
|
1337 TARGET_VTABLE_USES_DESCRIPTORS);
|
|
|
1338 }
|
|
|
1339
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1340 /* For use in assembly language. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1341 builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1342 builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1343
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1344 /* Misc. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1345 if (flag_gnu89_inline)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1346 cpp_define (pfile, "__GNUC_GNU_INLINE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1347 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1348 cpp_define (pfile, "__GNUC_STDC_INLINE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1349
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1350 if (flag_no_inline)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1351 cpp_define (pfile, "__NO_INLINE__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1352
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1353 if (flag_iso)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1354 cpp_define (pfile, "__STRICT_ANSI__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1355
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1356 if (!flag_signed_char)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1357 cpp_define (pfile, "__CHAR_UNSIGNED__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1358
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1359 if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1360 cpp_define (pfile, "__WCHAR_UNSIGNED__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1361
|
|
111
|
1362 cpp_atomic_builtins (pfile);
|
|
131
|
1363
|
|
|
1364 /* Show support for __builtin_speculation_safe_value () if the target
|
|
|
1365 has been updated to fully support it. */
|
|
|
1366 if (targetm.have_speculation_safe_value (false))
|
|
|
1367 cpp_define (pfile, "__HAVE_SPECULATION_SAFE_VALUE");
|
|
|
1368
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1369 #ifdef DWARF2_UNWIND_INFO
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1370 if (dwarf2out_do_cfi_asm ())
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1371 cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1372 #endif
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1373
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1374 /* Make the choice of ObjC runtime visible to source code. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1375 if (c_dialect_objc () && flag_next_runtime)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1376 cpp_define (pfile, "__NEXT_RUNTIME__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1377
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1378 /* Show the availability of some target pragmas. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1379 cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1380
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1381 /* Make the choice of the stack protector runtime visible to source code.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1382 The macro names and values here were chosen for compatibility with an
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1383 earlier implementation, i.e. ProPolice. */
|
|
111
|
1384 if (flag_stack_protect == 4)
|
|
|
1385 cpp_define (pfile, "__SSP_EXPLICIT__=4");
|
|
|
1386 if (flag_stack_protect == 3)
|
|
|
1387 cpp_define (pfile, "__SSP_STRONG__=3");
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1388 if (flag_stack_protect == 2)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1389 cpp_define (pfile, "__SSP_ALL__=2");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1390 else if (flag_stack_protect == 1)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1391 cpp_define (pfile, "__SSP__=1");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1392
|
|
111
|
1393 if (flag_openacc)
|
|
|
1394 cpp_define (pfile, "_OPENACC=201306");
|
|
|
1395
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1396 if (flag_openmp)
|
|
111
|
1397 cpp_define (pfile, "_OPENMP=201511");
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1398
|
|
111
|
1399 for (i = 0; i < NUM_INT_N_ENTS; i ++)
|
|
|
1400 if (int_n_enabled_p[i])
|
|
|
1401 {
|
|
|
1402 char buf[15+20];
|
|
|
1403 sprintf(buf, "__SIZEOF_INT%d__", int_n_data[i].bitsize);
|
|
|
1404 builtin_define_type_sizeof (buf,
|
|
|
1405 int_n_trees[i].signed_type);
|
|
|
1406 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1407 builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1408 builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1409 builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1410 unsigned_ptrdiff_type_node);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1411
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1412 /* A straightforward target hook doesn't work, because of problems
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1413 linking that hook's body when part of non-C front ends. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1414 # define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1415 # define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1416 # define builtin_define(TXT) cpp_define (pfile, TXT)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1417 # define builtin_assert(TXT) cpp_assert (pfile, TXT)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1418 TARGET_CPU_CPP_BUILTINS ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1419 TARGET_OS_CPP_BUILTINS ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1420 TARGET_OBJFMT_CPP_BUILTINS ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1421
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1422 /* Support the __declspec keyword by turning them into attributes.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1423 Note that the current way we do this may result in a collision
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1424 with predefined attributes later on. This can be solved by using
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1425 one attribute, say __declspec__, and passing args to it. The
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1426 problem with that approach is that args are not accumulated: each
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1427 new appearance would clobber any existing args. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1428 if (TARGET_DECLSPEC)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1429 builtin_define ("__declspec(x)=__attribute__((x))");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1430
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1431 /* If decimal floating point is supported, tell the user if the
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1432 alternate format (BID) is used instead of the standard (DPD)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1433 format. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1434 if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1435 cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1436 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1437
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1438 /* Pass an object-like macro. If it doesn't lie in the user's
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1439 namespace, defines it unconditionally. Otherwise define a version
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1440 with two leading underscores, and another version with two leading
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1441 and trailing underscores, and define the original only if an ISO
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1442 standard was not nominated.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1443
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1444 e.g. passing "unix" defines "__unix", "__unix__" and possibly
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1445 "unix". Passing "_mips" defines "__mips", "__mips__" and possibly
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1446 "_mips". */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1447 void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1448 builtin_define_std (const char *macro)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1449 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1450 size_t len = strlen (macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1451 char *buff = (char *) alloca (len + 5);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1452 char *p = buff + 2;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1453 char *q = p + len;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1454
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1455 /* prepend __ (or maybe just _) if in user's namespace. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1456 memcpy (p, macro, len + 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1457 if (!( *p == '_' && (p[1] == '_' || ISUPPER (p[1]))))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1458 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1459 if (*p != '_')
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1460 *--p = '_';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1461 if (p[1] != '_')
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1462 *--p = '_';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1463 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1464 cpp_define (parse_in, p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1465
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1466 /* If it was in user's namespace... */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1467 if (p != buff + 2)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1468 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1469 /* Define the macro with leading and following __. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1470 if (q[-1] != '_')
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1471 *q++ = '_';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1472 if (q[-2] != '_')
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1473 *q++ = '_';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1474 *q = '\0';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1475 cpp_define (parse_in, p);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1476
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1477 /* Finally, define the original macro if permitted. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1478 if (!flag_iso)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1479 cpp_define (parse_in, macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1480 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1481 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1482
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1483 /* Pass an object-like macro and a value to define it to. The third
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1484 parameter says whether or not to turn the value into a string
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1485 constant. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1486 void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1487 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1488 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1489 char *buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1490 size_t mlen = strlen (macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1491 size_t elen = strlen (expansion);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1492 size_t extra = 2; /* space for an = and a NUL */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1493
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1494 if (is_str)
|
|
111
|
1495 {
|
|
|
1496 char *quoted_expansion = (char *) alloca (elen * 4 + 1);
|
|
|
1497 const char *p;
|
|
|
1498 char *q;
|
|
|
1499 extra += 2; /* space for two quote marks */
|
|
|
1500 for (p = expansion, q = quoted_expansion; *p; p++)
|
|
|
1501 {
|
|
|
1502 switch (*p)
|
|
|
1503 {
|
|
|
1504 case '\n':
|
|
|
1505 *q++ = '\\';
|
|
|
1506 *q++ = 'n';
|
|
|
1507 break;
|
|
|
1508
|
|
|
1509 case '\t':
|
|
|
1510 *q++ = '\\';
|
|
|
1511 *q++ = 't';
|
|
|
1512 break;
|
|
|
1513
|
|
|
1514 case '\\':
|
|
|
1515 *q++ = '\\';
|
|
|
1516 *q++ = '\\';
|
|
|
1517 break;
|
|
|
1518
|
|
|
1519 case '"':
|
|
|
1520 *q++ = '\\';
|
|
|
1521 *q++ = '"';
|
|
|
1522 break;
|
|
|
1523
|
|
|
1524 default:
|
|
|
1525 if (ISPRINT ((unsigned char) *p))
|
|
|
1526 *q++ = *p;
|
|
|
1527 else
|
|
|
1528 {
|
|
|
1529 sprintf (q, "\\%03o", (unsigned char) *p);
|
|
|
1530 q += 4;
|
|
|
1531 }
|
|
|
1532 }
|
|
|
1533 }
|
|
|
1534 *q = '\0';
|
|
|
1535 expansion = quoted_expansion;
|
|
|
1536 elen = q - expansion;
|
|
|
1537 }
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1538
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1539 buf = (char *) alloca (mlen + elen + extra);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1540 if (is_str)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1541 sprintf (buf, "%s=\"%s\"", macro, expansion);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1542 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1543 sprintf (buf, "%s=%s", macro, expansion);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1544
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1545 cpp_define (parse_in, buf);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1546 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1547
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1548
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1549 /* Pass an object-like macro and an integer value to define it to. */
|
|
111
|
1550 void
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1551 builtin_define_with_int_value (const char *macro, HOST_WIDE_INT value)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1552 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1553 char *buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1554 size_t mlen = strlen (macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1555 size_t vlen = 18;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1556 size_t extra = 2; /* space for = and NUL. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1557
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1558 buf = (char *) alloca (mlen + vlen + extra);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1559 memcpy (buf, macro, mlen);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1560 buf[mlen] = '=';
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1561 sprintf (buf + mlen + 1, HOST_WIDE_INT_PRINT_DEC, value);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1562
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1563 cpp_define (parse_in, buf);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1564 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1565
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1566 /* builtin_define_with_hex_fp_value is very expensive, so the following
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1567 array and function allows it to be done lazily when __DBL_MAX__
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1568 etc. is first used. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1569
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1570 struct GTY(()) lazy_hex_fp_value_struct
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1571 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1572 const char *hex_str;
|
|
111
|
1573 machine_mode mode;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1574 int digits;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1575 const char *fp_suffix;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1576 };
|
|
131
|
1577 /* Number of the expensive to compute macros we should evaluate lazily.
|
|
|
1578 Each builtin_define_float_constants invocation calls
|
|
|
1579 builtin_define_with_hex_fp_value 4 times and builtin_define_float_constants
|
|
|
1580 is called for FLT, DBL, LDBL and up to NUM_FLOATN_NX_TYPES times for
|
|
|
1581 FLTNN*. */
|
|
|
1582 #define LAZY_HEX_FP_VALUES_CNT (4 * (3 + NUM_FLOATN_NX_TYPES))
|
|
|
1583 static GTY(()) struct lazy_hex_fp_value_struct
|
|
|
1584 lazy_hex_fp_values[LAZY_HEX_FP_VALUES_CNT];
|
|
|
1585 static GTY(()) unsigned lazy_hex_fp_value_count;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1586
|
|
131
|
1587 static void
|
|
|
1588 lazy_hex_fp_value (cpp_reader *, cpp_macro *macro, unsigned num)
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1589 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1590 REAL_VALUE_TYPE real;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1591 char dec_str[64], buf1[256];
|
|
131
|
1592
|
|
|
1593 gcc_checking_assert (num < lazy_hex_fp_value_count);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1594
|
|
131
|
1595 real_from_string (&real, lazy_hex_fp_values[num].hex_str);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1596 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str),
|
|
131
|
1597 lazy_hex_fp_values[num].digits, 0,
|
|
|
1598 lazy_hex_fp_values[num].mode);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1599
|
|
131
|
1600 size_t len
|
|
|
1601 = sprintf (buf1, "%s%s", dec_str, lazy_hex_fp_values[num].fp_suffix);
|
|
|
1602 gcc_assert (len < sizeof (buf1));
|
|
|
1603 for (unsigned idx = 0; idx < macro->count; idx++)
|
|
|
1604 if (macro->exp.tokens[idx].type == CPP_NUMBER)
|
|
|
1605 {
|
|
|
1606 macro->exp.tokens[idx].val.str.len = len;
|
|
|
1607 macro->exp.tokens[idx].val.str.text
|
|
|
1608 = (const unsigned char *) ggc_strdup (buf1);
|
|
|
1609 return;
|
|
|
1610 }
|
|
|
1611
|
|
|
1612 /* We must have replaced a token. */
|
|
|
1613 gcc_unreachable ();
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1614 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1615
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1616 /* Pass an object-like macro a hexadecimal floating-point value. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1617 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1618 builtin_define_with_hex_fp_value (const char *macro,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1619 tree type, int digits,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1620 const char *hex_str,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1621 const char *fp_suffix,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1622 const char *fp_cast)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1623 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1624 REAL_VALUE_TYPE real;
|
|
131
|
1625 char dec_str[64], buf[256], buf1[128], buf2[64];
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1626
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1627 /* This is very expensive, so if possible expand them lazily. */
|
|
131
|
1628 if (lazy_hex_fp_value_count < LAZY_HEX_FP_VALUES_CNT
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1629 && flag_dump_macros == 0
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1630 && !cpp_get_options (parse_in)->traditional)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1631 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1632 if (lazy_hex_fp_value_count == 0)
|
|
131
|
1633 cpp_get_callbacks (parse_in)->user_lazy_macro = lazy_hex_fp_value;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1634 sprintf (buf2, fp_cast, "1.1");
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1635 sprintf (buf1, "%s=%s", macro, buf2);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1636 cpp_define (parse_in, buf1);
|
|
131
|
1637 struct cpp_hashnode *node = C_CPP_HASHNODE (get_identifier (macro));
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1638 lazy_hex_fp_values[lazy_hex_fp_value_count].hex_str
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1639 = ggc_strdup (hex_str);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1640 lazy_hex_fp_values[lazy_hex_fp_value_count].mode = TYPE_MODE (type);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1641 lazy_hex_fp_values[lazy_hex_fp_value_count].digits = digits;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1642 lazy_hex_fp_values[lazy_hex_fp_value_count].fp_suffix = fp_suffix;
|
|
131
|
1643 cpp_define_lazily (parse_in, node, lazy_hex_fp_value_count++);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1644 return;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1645 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1646
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1647 /* Hex values are really cool and convenient, except that they're
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1648 not supported in strict ISO C90 mode. First, the "p-" sequence
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1649 is not valid as part of a preprocessor number. Second, we get a
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1650 pedwarn from the preprocessor, which has no context, so we can't
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1651 suppress the warning with __extension__.
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1652
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1653 So instead what we do is construct the number in hex (because
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1654 it's easy to get the exact correct value), parse it as a real,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1655 then print it back out as decimal. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1656
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1657 real_from_string (&real, hex_str);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1658 real_to_decimal_for_mode (dec_str, &real, sizeof (dec_str), digits, 0,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1659 TYPE_MODE (type));
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1660
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1661 /* Assemble the macro in the following fashion
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1662 macro = fp_cast [dec_str fp_suffix] */
|
|
131
|
1663 sprintf (buf2, "%s%s", dec_str, fp_suffix);
|
|
|
1664 sprintf (buf1, fp_cast, buf2);
|
|
|
1665 sprintf (buf, "%s=%s", macro, buf1);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1666
|
|
131
|
1667 cpp_define (parse_in, buf);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1668 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1669
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1670 /* Return a string constant for the suffix for a value of type TYPE
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1671 promoted according to the integer promotions. The type must be one
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1672 of the standard integer type nodes. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1673
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1674 static const char *
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1675 type_suffix (tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1676 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1677 static const char *const suffixes[] = { "", "U", "L", "UL", "LL", "ULL" };
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1678 int unsigned_suffix;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1679 int is_long;
|
|
111
|
1680 int tp = TYPE_PRECISION (type);
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1681
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1682 if (type == long_long_integer_type_node
|
|
111
|
1683 || type == long_long_unsigned_type_node
|
|
|
1684 || tp > TYPE_PRECISION (long_integer_type_node))
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1685 is_long = 2;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1686 else if (type == long_integer_type_node
|
|
111
|
1687 || type == long_unsigned_type_node
|
|
|
1688 || tp > TYPE_PRECISION (integer_type_node))
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1689 is_long = 1;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1690 else if (type == integer_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1691 || type == unsigned_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1692 || type == short_integer_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1693 || type == short_unsigned_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1694 || type == signed_char_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1695 || type == unsigned_char_type_node
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1696 /* ??? "char" is not a signed or unsigned integer type and
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1697 so is not permitted for the standard typedefs, but some
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1698 systems use it anyway. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1699 || type == char_type_node)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1700 is_long = 0;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1701 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1702 gcc_unreachable ();
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1703
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1704 unsigned_suffix = TYPE_UNSIGNED (type);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1705 if (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1706 unsigned_suffix = 0;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1707 return suffixes[is_long * 2 + unsigned_suffix];
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1708 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1709
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1710 /* Define MACRO as a <stdint.h> constant-suffix macro for TYPE. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1711 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1712 builtin_define_constants (const char *macro, tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1713 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1714 const char *suffix;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1715 char *buf;
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1716
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1717 suffix = type_suffix (type);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1718
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1719 if (suffix[0] == 0)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1720 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1721 buf = (char *) alloca (strlen (macro) + 6);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1722 sprintf (buf, "%s(c)=c", macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1723 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1724 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1725 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1726 buf = (char *) alloca (strlen (macro) + 9 + strlen (suffix) + 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1727 sprintf (buf, "%s(c)=c ## %s", macro, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1728 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1729
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1730 cpp_define (parse_in, buf);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1731 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1732
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1733 /* Define MAX for TYPE based on the precision of the type. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1734
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1735 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1736 builtin_define_type_max (const char *macro, tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1737 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1738 builtin_define_type_minmax (NULL, macro, type);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1739 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1740
|
|
111
|
1741 /* Given a value with COUNT LSBs set, fill BUF with a hexidecimal
|
|
|
1742 representation of that value. For example, a COUNT of 10 would
|
|
|
1743 return "0x3ff". */
|
|
|
1744
|
|
|
1745 static void
|
|
|
1746 print_bits_of_hex (char *buf, int bufsz, int count)
|
|
|
1747 {
|
|
|
1748 gcc_assert (bufsz > 3);
|
|
|
1749 *buf++ = '0';
|
|
|
1750 *buf++ = 'x';
|
|
|
1751 bufsz -= 2;
|
|
|
1752
|
|
|
1753 gcc_assert (count > 0);
|
|
|
1754
|
|
|
1755 switch (count % 4) {
|
|
|
1756 case 0:
|
|
|
1757 break;
|
|
|
1758 case 1:
|
|
|
1759 *buf++ = '1';
|
|
|
1760 bufsz --;
|
|
|
1761 count -= 1;
|
|
|
1762 break;
|
|
|
1763 case 2:
|
|
|
1764 *buf++ = '3';
|
|
|
1765 bufsz --;
|
|
|
1766 count -= 2;
|
|
|
1767 break;
|
|
|
1768 case 3:
|
|
|
1769 *buf++ = '7';
|
|
|
1770 bufsz --;
|
|
|
1771 count -= 3;
|
|
|
1772 break;
|
|
|
1773 }
|
|
|
1774 while (count >= 4)
|
|
|
1775 {
|
|
|
1776 gcc_assert (bufsz > 1);
|
|
|
1777 *buf++ = 'f';
|
|
|
1778 bufsz --;
|
|
|
1779 count -= 4;
|
|
|
1780 }
|
|
|
1781 gcc_assert (bufsz > 0);
|
|
|
1782 *buf++ = 0;
|
|
|
1783 }
|
|
|
1784
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1785 /* Define MIN_MACRO (if not NULL) and MAX_MACRO for TYPE based on the
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1786 precision of the type. */
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1787
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1788 static void
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1789 builtin_define_type_minmax (const char *min_macro, const char *max_macro,
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1790 tree type)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1791 {
|
|
111
|
1792 #define PBOH_SZ (MAX_BITSIZE_MODE_ANY_INT/4+4)
|
|
|
1793 char value[PBOH_SZ];
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1794
|
|
111
|
1795 const char *suffix;
|
|
|
1796 char *buf;
|
|
|
1797 int bits;
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1798
|
|
111
|
1799 bits = TYPE_PRECISION (type) + (TYPE_UNSIGNED (type) ? 0 : -1);
|
|
|
1800
|
|
|
1801 print_bits_of_hex (value, PBOH_SZ, bits);
|
|
|
1802
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1803 suffix = type_suffix (type);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1804
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1805 buf = (char *) alloca (strlen (max_macro) + 1 + strlen (value)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1806 + strlen (suffix) + 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1807 sprintf (buf, "%s=%s%s", max_macro, value, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1808
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1809 cpp_define (parse_in, buf);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1810
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1811 if (min_macro)
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1812 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1813 if (TYPE_UNSIGNED (type))
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1814 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1815 buf = (char *) alloca (strlen (min_macro) + 2 + strlen (suffix) + 1);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1816 sprintf (buf, "%s=0%s", min_macro, suffix);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1817 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1818 else
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1819 {
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1820 buf = (char *) alloca (strlen (min_macro) + 3
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1821 + strlen (max_macro) + 6);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1822 sprintf (buf, "%s=(-%s - 1)", min_macro, max_macro);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1823 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1824 cpp_define (parse_in, buf);
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1825 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1826 }
|
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1827
|
|
111
|
1828 /* Define WIDTH_MACRO for the width of TYPE. If TYPE2 is not NULL,
|
|
|
1829 both types must have the same width. */
|
|
|
1830
|
|
|
1831 static void
|
|
|
1832 builtin_define_type_width (const char *width_macro, tree type, tree type2)
|
|
|
1833 {
|
|
|
1834 if (type2 != NULL_TREE)
|
|
|
1835 gcc_assert (TYPE_PRECISION (type) == TYPE_PRECISION (type2));
|
|
|
1836 builtin_define_with_int_value (width_macro, TYPE_PRECISION (type));
|
|
|
1837 }
|
|
|
1838
|
68
Nobuyasu Oshiro <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1839 #include "gt-c-family-c-cppbuiltin.h"
|
