Branch data Line data Source code
1 : : /* HOST_WIDE_INT definitions for the GNU compiler.
2 : : Copyright (C) 1998-2024 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
6 : : Provide definitions for macros which depend on HOST_BITS_PER_INT
7 : : and HOST_BITS_PER_LONG. */
8 : :
9 : : #ifndef GCC_HWINT_H
10 : : #define GCC_HWINT_H
11 : :
12 : : /* This describes the machine the compiler is hosted on. */
13 : : #define HOST_BITS_PER_CHAR CHAR_BIT
14 : : #define HOST_BITS_PER_SHORT (CHAR_BIT * SIZEOF_SHORT)
15 : : #define HOST_BITS_PER_INT (CHAR_BIT * SIZEOF_INT)
16 : : #define HOST_BITS_PER_LONG (CHAR_BIT * SIZEOF_LONG)
17 : : #define HOST_BITS_PER_PTR (CHAR_BIT * SIZEOF_VOID_P)
18 : :
19 : : /* The string that should be inserted into a printf style format to
20 : : indicate a "long" operand. */
21 : : #ifndef HOST_LONG_FORMAT
22 : : #define HOST_LONG_FORMAT "l"
23 : : #endif
24 : :
25 : : /* The string that should be inserted into a printf style format to
26 : : indicate a "long long" operand. */
27 : : #ifndef HOST_LONG_LONG_FORMAT
28 : : #define HOST_LONG_LONG_FORMAT "ll"
29 : : #endif
30 : :
31 : : /* If HAVE_LONG_LONG and SIZEOF_LONG_LONG aren't defined, but
32 : : GCC_VERSION >= 3000, assume this is the second or later stage of a
33 : : bootstrap, we do have long long, and it's 64 bits. (This is
34 : : required by C99; we do have some ports that violate that assumption
35 : : but they're all cross-compile-only.) Just in case, force a
36 : : constraint violation if that assumption is incorrect. */
37 : : #if !defined HAVE_LONG_LONG
38 : : # if GCC_VERSION >= 3000
39 : : # define HAVE_LONG_LONG 1
40 : : # define SIZEOF_LONG_LONG 8
41 : : extern char sizeof_long_long_must_be_8[sizeof (long long) == 8 ? 1 : -1];
42 : : # endif
43 : : #endif
44 : :
45 : : #ifdef HAVE_LONG_LONG
46 : : # define HOST_BITS_PER_LONGLONG (CHAR_BIT * SIZEOF_LONG_LONG)
47 : : #endif
48 : :
49 : : /* Set HOST_WIDE_INT, this should be always 64 bits.
50 : : The underlying type is matched to that of int64_t and assumed
51 : : to be either long or long long. */
52 : :
53 : : #define HOST_BITS_PER_WIDE_INT 64
54 : : #if INT64_T_IS_LONG
55 : : # define HOST_WIDE_INT long
56 : : # define HOST_WIDE_INT_C(X) X ## L
57 : : #else
58 : : # if HOST_BITS_PER_LONGLONG == 64
59 : : # define HOST_WIDE_INT long long
60 : : # define HOST_WIDE_INT_C(X) X ## LL
61 : : # else
62 : : #error "Unable to find a suitable type for HOST_WIDE_INT"
63 : : # endif
64 : : #endif
65 : :
66 : : #define HOST_WIDE_INT_UC(X) HOST_WIDE_INT_C (X ## U)
67 : : #define HOST_WIDE_INT_0 HOST_WIDE_INT_C (0)
68 : : #define HOST_WIDE_INT_0U HOST_WIDE_INT_UC (0)
69 : : #define HOST_WIDE_INT_1 HOST_WIDE_INT_C (1)
70 : : #define HOST_WIDE_INT_1U HOST_WIDE_INT_UC (1)
71 : : #define HOST_WIDE_INT_M1 HOST_WIDE_INT_C (-1)
72 : : #define HOST_WIDE_INT_M1U HOST_WIDE_INT_UC (-1)
73 : :
74 : : /* This is a magic identifier which allows GCC to figure out the type
75 : : of HOST_WIDE_INT for %wd specifier checks. You must issue this
76 : : typedef before using the __asm_fprintf__ format attribute. */
77 : : typedef HOST_WIDE_INT __gcc_host_wide_int__;
78 : :
79 : : /* Provide C99 <inttypes.h> style format definitions for 64bits. */
80 : : #ifndef HAVE_INTTYPES_H
81 : : #if INT64_T_IS_LONG
82 : : # define GCC_PRI64 HOST_LONG_FORMAT
83 : : #else
84 : : # define GCC_PRI64 HOST_LONG_LONG_FORMAT
85 : : #endif
86 : : #undef PRId64
87 : : #define PRId64 GCC_PRI64 "d"
88 : : #undef PRIi64
89 : : #define PRIi64 GCC_PRI64 "i"
90 : : #undef PRIo64
91 : : #define PRIo64 GCC_PRI64 "o"
92 : : #undef PRIu64
93 : : #define PRIu64 GCC_PRI64 "u"
94 : : #undef PRIx64
95 : : #define PRIx64 GCC_PRI64 "x"
96 : : #undef PRIX64
97 : : #define PRIX64 GCC_PRI64 "X"
98 : : #endif
99 : :
100 : : /* Various printf format strings for HOST_WIDE_INT. */
101 : :
102 : : #if INT64_T_IS_LONG
103 : : # define HOST_WIDE_INT_PRINT HOST_LONG_FORMAT
104 : : # define HOST_WIDE_INT_PRINT_C "L"
105 : : #else
106 : : # define HOST_WIDE_INT_PRINT HOST_LONG_LONG_FORMAT
107 : : # define HOST_WIDE_INT_PRINT_C "LL"
108 : : #endif
109 : :
110 : : #define HOST_WIDE_INT_PRINT_DEC "%" PRId64
111 : : #define HOST_WIDE_INT_PRINT_DEC_C "%" PRId64 HOST_WIDE_INT_PRINT_C
112 : : #define HOST_WIDE_INT_PRINT_UNSIGNED "%" PRIu64
113 : : #define HOST_WIDE_INT_PRINT_HEX "%#" PRIx64
114 : : #define HOST_WIDE_INT_PRINT_HEX_PURE "%" PRIx64
115 : : #define HOST_WIDE_INT_PRINT_DOUBLE_HEX "0x%" PRIx64 "%016" PRIx64
116 : : #define HOST_WIDE_INT_PRINT_PADDED_HEX "%016" PRIx64
117 : :
118 : : /* Similarly format modifier for printing size_t. As not all hosts support
119 : : z modifier in printf, use GCC_PRISZ and cast argument to fmt_size_t.
120 : : So, instead of doing fprintf ("%zu\n", sizeof (x) * y); use
121 : : fprintf (HOST_SIZE_T_PRINT_UNSIGNED "\n",
122 : : (fmt_size_t) (sizeof (x) * y)); */
123 : : #if SIZE_MAX <= UINT_MAX
124 : : # define GCC_PRISZ ""
125 : : # define fmt_size_t unsigned int
126 : : #elif SIZE_MAX <= ULONG_MAX
127 : : # define GCC_PRISZ HOST_LONG_FORMAT
128 : : # define fmt_size_t unsigned long int
129 : : #else
130 : : # define GCC_PRISZ HOST_LONG_LONG_FORMAT
131 : : # define fmt_size_t unsigned long long int
132 : : #endif
133 : :
134 : : #define HOST_SIZE_T_PRINT_DEC "%" GCC_PRISZ "d"
135 : : #define HOST_SIZE_T_PRINT_UNSIGNED "%" GCC_PRISZ "u"
136 : : #define HOST_SIZE_T_PRINT_HEX "%#" GCC_PRISZ "x"
137 : : #define HOST_SIZE_T_PRINT_HEX_PURE "%" GCC_PRISZ "x"
138 : :
139 : : /* Define HOST_WIDEST_FAST_INT to the widest integer type supported
140 : : efficiently in hardware. (That is, the widest integer type that fits
141 : : in a hardware register.) Normally this is "long" but on some hosts it
142 : : should be "long long" or "__int64". This is no convenient way to
143 : : autodetect this, so such systems must set a flag in config.host; see there
144 : : for details. */
145 : :
146 : : #ifdef USE_LONG_LONG_FOR_WIDEST_FAST_INT
147 : : # ifdef HAVE_LONG_LONG
148 : : # define HOST_WIDEST_FAST_INT long long
149 : : # define HOST_BITS_PER_WIDEST_FAST_INT HOST_BITS_PER_LONGLONG
150 : : # else
151 : : # error "Your host said it wanted to use long long but that does not exist"
152 : : # endif
153 : : #else
154 : : # define HOST_WIDEST_FAST_INT long
155 : : # define HOST_BITS_PER_WIDEST_FAST_INT HOST_BITS_PER_LONG
156 : : #endif
157 : :
158 : : /* Inline functions operating on HOST_WIDE_INT. */
159 : :
160 : : /* Return X with all but the lowest bit masked off. */
161 : :
162 : : inline unsigned HOST_WIDE_INT
163 : 2078936246 : least_bit_hwi (unsigned HOST_WIDE_INT x)
164 : : {
165 : 2078897927 : return (x & -x);
166 : : }
167 : :
168 : : /* True if X is zero or a power of two. */
169 : :
170 : : inline bool
171 : 2009137755 : pow2_or_zerop (unsigned HOST_WIDE_INT x)
172 : : {
173 : 2009380105 : return least_bit_hwi (x) == x;
174 : : }
175 : :
176 : : /* True if X is a power of two. */
177 : :
178 : : inline bool
179 : 265371742 : pow2p_hwi (unsigned HOST_WIDE_INT x)
180 : : {
181 : 263207598 : return x && pow2_or_zerop (x);
182 : : }
183 : :
184 : : #if GCC_VERSION < 3004
185 : :
186 : : extern int clz_hwi (unsigned HOST_WIDE_INT x);
187 : : extern int ctz_hwi (unsigned HOST_WIDE_INT x);
188 : : extern int ffs_hwi (unsigned HOST_WIDE_INT x);
189 : :
190 : : /* Return the number of set bits in X. */
191 : : extern int popcount_hwi (unsigned HOST_WIDE_INT x);
192 : :
193 : : /* Return log2, or -1 if not exact. */
194 : : extern int exact_log2 (unsigned HOST_WIDE_INT);
195 : :
196 : : /* Return floor of log2, with -1 for zero. */
197 : : extern int floor_log2 (unsigned HOST_WIDE_INT);
198 : :
199 : : /* Return the smallest n such that 2**n >= X. */
200 : : extern int ceil_log2 (unsigned HOST_WIDE_INT);
201 : :
202 : : #else /* GCC_VERSION >= 3004 */
203 : :
204 : : /* For convenience, define 0 -> word_size. */
205 : : inline int
206 : 3897649713 : clz_hwi (unsigned HOST_WIDE_INT x)
207 : : {
208 : 2928256875 : if (x == 0)
209 : : return HOST_BITS_PER_WIDE_INT;
210 : : # if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
211 : 2959734729 : return __builtin_clzl (x);
212 : : # elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG
213 : : return __builtin_clzll (x);
214 : : # else
215 : : return __builtin_clz (x);
216 : : # endif
217 : : }
218 : :
219 : : inline int
220 : 2880887111 : ctz_hwi (unsigned HOST_WIDE_INT x)
221 : : {
222 : 2880056080 : if (x == 0)
223 : : return HOST_BITS_PER_WIDE_INT;
224 : : # if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
225 : 2778880488 : return __builtin_ctzl (x);
226 : : # elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG
227 : : return __builtin_ctzll (x);
228 : : # else
229 : : return __builtin_ctz (x);
230 : : # endif
231 : : }
232 : :
233 : : inline int
234 : 4877656622 : ffs_hwi (unsigned HOST_WIDE_INT x)
235 : : {
236 : : # if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
237 : 4659934779 : return __builtin_ffsl (x);
238 : : # elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG
239 : : return __builtin_ffsll (x);
240 : : # else
241 : : return __builtin_ffs (x);
242 : : # endif
243 : : }
244 : :
245 : : inline int
246 : 85821214 : popcount_hwi (unsigned HOST_WIDE_INT x)
247 : : {
248 : : # if HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONG
249 : 85821214 : return __builtin_popcountl (x);
250 : : # elif HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_LONGLONG
251 : : return __builtin_popcountll (x);
252 : : # else
253 : : return __builtin_popcount (x);
254 : : # endif
255 : : }
256 : :
257 : : inline int
258 : 3383335753 : floor_log2 (unsigned HOST_WIDE_INT x)
259 : : {
260 : 5055717975 : return HOST_BITS_PER_WIDE_INT - 1 - clz_hwi (x);
261 : : }
262 : :
263 : : inline int
264 : 54192740 : ceil_log2 (unsigned HOST_WIDE_INT x)
265 : : {
266 : 64669392 : return x == 0 ? 0 : floor_log2 (x - 1) + 1;
267 : : }
268 : :
269 : : inline int
270 : 111127311 : exact_log2 (unsigned HOST_WIDE_INT x)
271 : : {
272 : 295636133 : return pow2p_hwi (x) ? ctz_hwi (x) : -1;
273 : : }
274 : :
275 : : #endif /* GCC_VERSION >= 3004 */
276 : :
277 : : #define HOST_WIDE_INT_MIN (HOST_WIDE_INT) \
278 : : (HOST_WIDE_INT_1U << (HOST_BITS_PER_WIDE_INT - 1))
279 : : #define HOST_WIDE_INT_MAX (~(HOST_WIDE_INT_MIN))
280 : :
281 : : extern HOST_WIDE_INT abs_hwi (HOST_WIDE_INT);
282 : : extern unsigned HOST_WIDE_INT absu_hwi (HOST_WIDE_INT);
283 : : extern HOST_WIDE_INT gcd (HOST_WIDE_INT, HOST_WIDE_INT);
284 : : extern HOST_WIDE_INT pos_mul_hwi (HOST_WIDE_INT, HOST_WIDE_INT);
285 : : extern HOST_WIDE_INT mul_hwi (HOST_WIDE_INT, HOST_WIDE_INT);
286 : : extern HOST_WIDE_INT least_common_multiple (HOST_WIDE_INT, HOST_WIDE_INT);
287 : :
288 : : /* Like ctz_hwi, except 0 when x == 0. */
289 : :
290 : : inline int
291 : 91742729 : ctz_or_zero (unsigned HOST_WIDE_INT x)
292 : : {
293 : 91742729 : return ffs_hwi (x) - 1;
294 : : }
295 : :
296 : : /* Sign extend SRC starting from PREC. */
297 : :
298 : : inline HOST_WIDE_INT
299 : 19808061857 : sext_hwi (HOST_WIDE_INT src, unsigned int prec)
300 : : {
301 : 19808061857 : if (prec == HOST_BITS_PER_WIDE_INT)
302 : : return src;
303 : : else
304 : : #if defined (__GNUC__)
305 : : {
306 : : /* Take the faster path if the implementation-defined bits it's relying
307 : : on are implemented the way we expect them to be. Namely, conversion
308 : : from unsigned to signed preserves bit pattern, and right shift of
309 : : a signed value propagates the sign bit.
310 : : We have to convert from signed to unsigned and back, because when left
311 : : shifting signed values, any overflow is undefined behavior. */
312 : 18409220790 : gcc_checking_assert (prec < HOST_BITS_PER_WIDE_INT);
313 : 18409220790 : int shift = HOST_BITS_PER_WIDE_INT - prec;
314 : 18409220790 : return ((HOST_WIDE_INT) ((unsigned HOST_WIDE_INT) src << shift)) >> shift;
315 : : }
316 : : #else
317 : : {
318 : : /* Fall back to the slower, well defined path otherwise. */
319 : : gcc_checking_assert (prec < HOST_BITS_PER_WIDE_INT);
320 : : HOST_WIDE_INT sign_mask = HOST_WIDE_INT_1 << (prec - 1);
321 : : HOST_WIDE_INT value_mask = (HOST_WIDE_INT_1U << prec) - HOST_WIDE_INT_1U;
322 : : return (((src & value_mask) ^ sign_mask) - sign_mask);
323 : : }
324 : : #endif
325 : : }
326 : :
327 : : /* Zero extend SRC starting from PREC. */
328 : : inline unsigned HOST_WIDE_INT
329 : 13351296640 : zext_hwi (unsigned HOST_WIDE_INT src, unsigned int prec)
330 : : {
331 : 13351296640 : if (prec == HOST_BITS_PER_WIDE_INT)
332 : : return src;
333 : : else
334 : : {
335 : 13349571955 : gcc_checking_assert (prec < HOST_BITS_PER_WIDE_INT);
336 : 13349571955 : return src & ((HOST_WIDE_INT_1U << prec) - 1);
337 : : }
338 : : }
339 : :
340 : : /* Compute the absolute value of X. */
341 : :
342 : : inline HOST_WIDE_INT
343 : 70912586 : abs_hwi (HOST_WIDE_INT x)
344 : : {
345 : 70912586 : gcc_checking_assert (x != HOST_WIDE_INT_MIN);
346 : 70912586 : return x >= 0 ? x : -x;
347 : : }
348 : :
349 : : /* Compute the absolute value of X as an unsigned type. */
350 : :
351 : : inline unsigned HOST_WIDE_INT
352 : 6086200785 : absu_hwi (HOST_WIDE_INT x)
353 : : {
354 : 6079999583 : return x >= 0 ? (unsigned HOST_WIDE_INT)x : -(unsigned HOST_WIDE_INT)x;
355 : : }
356 : :
357 : : /* Compute the sum of signed A and B and indicate in *OVERFLOW whether
358 : : that operation overflowed. */
359 : :
360 : : inline HOST_WIDE_INT
361 : 2972214 : add_hwi (HOST_WIDE_INT a, HOST_WIDE_INT b, bool *overflow)
362 : : {
363 : : #if GCC_VERSION < 11000
364 : : unsigned HOST_WIDE_INT result = a + (unsigned HOST_WIDE_INT)b;
365 : : if ((((result ^ a) & (result ^ b))
366 : : >> (HOST_BITS_PER_WIDE_INT - 1)) & 1)
367 : : *overflow = true;
368 : : else
369 : : *overflow = false;
370 : : return result;
371 : : #else
372 : 2972214 : HOST_WIDE_INT result;
373 : 2972214 : *overflow = __builtin_add_overflow (a, b, &result);
374 : 2972214 : return result;
375 : : #endif
376 : : }
377 : :
378 : : /* Compute the product of signed A and B and indicate in *OVERFLOW whether
379 : : that operation overflowed. */
380 : :
381 : : inline HOST_WIDE_INT
382 : 2972214 : mul_hwi (HOST_WIDE_INT a, HOST_WIDE_INT b, bool *overflow)
383 : : {
384 : : #if GCC_VERSION < 11000
385 : : unsigned HOST_WIDE_INT result = a * (unsigned HOST_WIDE_INT)b;
386 : : if ((a == -1 && b == HOST_WIDE_INT_MIN)
387 : : || (a != 0 && (HOST_WIDE_INT)result / a != b))
388 : : *overflow = true;
389 : : else
390 : : *overflow = false;
391 : : return result;
392 : : #else
393 : 2972214 : HOST_WIDE_INT result;
394 : 2972214 : *overflow = __builtin_mul_overflow (a, b, &result);
395 : 2972214 : return result;
396 : : #endif
397 : : }
398 : :
399 : : #endif /* ! GCC_HWINT_H */
|
