1 /* Operations with very long integers. -*- C++ -*-
2 Copyright (C) 2012-2022 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 3, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
23 /* wide-int.[cc|h] implements a class that efficiently performs
24 mathematical operations on finite precision integers. wide_ints
25 are designed to be transient - they are not for long term storage
26 of values. There is tight integration between wide_ints and the
27 other longer storage GCC representations (rtl and tree).
29 The actual precision of a wide_int depends on the flavor. There
30 are three predefined flavors:
32 1) wide_int (the default). This flavor does the math in the
33 precision of its input arguments. It is assumed (and checked)
34 that the precisions of the operands and results are consistent.
35 This is the most efficient flavor. It is not possible to examine
36 bits above the precision that has been specified. Because of
37 this, the default flavor has semantics that are simple to
38 understand and in general model the underlying hardware that the
39 compiler is targetted for.
41 This flavor must be used at the RTL level of gcc because there
42 is, in general, not enough information in the RTL representation
43 to extend a value beyond the precision specified in the mode.
45 This flavor should also be used at the TREE and GIMPLE levels of
46 the compiler except for the circumstances described in the
47 descriptions of the other two flavors.
49 The default wide_int representation does not contain any
50 information inherent about signedness of the represented value,
51 so it can be used to represent both signed and unsigned numbers.
52 For operations where the results depend on signedness (full width
53 multiply, division, shifts, comparisons, and operations that need
54 overflow detected), the signedness must be specified separately.
56 2) offset_int. This is a fixed-precision integer that can hold
57 any address offset, measured in either bits or bytes, with at
58 least one extra sign bit. At the moment the maximum address
59 size GCC supports is 64 bits. With 8-bit bytes and an extra
60 sign bit, offset_int therefore needs to have at least 68 bits
61 of precision. We round this up to 128 bits for efficiency.
62 Values of type T are converted to this precision by sign- or
63 zero-extending them based on the signedness of T.
65 The extra sign bit means that offset_int is effectively a signed
66 128-bit integer, i.e. it behaves like int128_t.
68 Since the values are logically signed, there is no need to
69 distinguish between signed and unsigned operations. Sign-sensitive
70 comparison operators <, <=, > and >= are therefore supported.
71 Shift operators << and >> are also supported, with >> being
72 an _arithmetic_ right shift.
74 [ Note that, even though offset_int is effectively int128_t,
75 it can still be useful to use unsigned comparisons like
76 wi::leu_p (a, b) as a more efficient short-hand for
79 3) widest_int. This representation is an approximation of
80 infinite precision math. However, it is not really infinite
81 precision math as in the GMP library. It is really finite
82 precision math where the precision is 4 times the size of the
83 largest integer that the target port can represent.
85 Like offset_int, widest_int is wider than all the values that
86 it needs to represent, so the integers are logically signed.
87 Sign-sensitive comparison operators <, <=, > and >= are supported,
90 There are several places in the GCC where this should/must be used:
92 * Code that does induction variable optimizations. This code
93 works with induction variables of many different types at the
94 same time. Because of this, it ends up doing many different
95 calculations where the operands are not compatible types. The
96 widest_int makes this easy, because it provides a field where
97 nothing is lost when converting from any variable,
99 * There are a small number of passes that currently use the
100 widest_int that should use the default. These should be
103 There are surprising features of offset_int and widest_int
104 that the users should be careful about:
106 1) Shifts and rotations are just weird. You have to specify a
107 precision in which the shift or rotate is to happen in. The bits
108 above this precision are zeroed. While this is what you
109 want, it is clearly non obvious.
111 2) Larger precision math sometimes does not produce the same
112 answer as would be expected for doing the math at the proper
113 precision. In particular, a multiply followed by a divide will
114 produce a different answer if the first product is larger than
115 what can be represented in the input precision.
117 The offset_int and the widest_int flavors are more expensive
118 than the default wide int, so in addition to the caveats with these
119 two, the default is the prefered representation.
121 All three flavors of wide_int are represented as a vector of
122 HOST_WIDE_INTs. The default and widest_int vectors contain enough elements
123 to hold a value of MAX_BITSIZE_MODE_ANY_INT bits. offset_int contains only
124 enough elements to hold ADDR_MAX_PRECISION bits. The values are stored
125 in the vector with the least significant HOST_BITS_PER_WIDE_INT bits
128 The default wide_int contains three fields: the vector (VAL),
129 the precision and a length (LEN). The length is the number of HWIs
130 needed to represent the value. widest_int and offset_int have a
131 constant precision that cannot be changed, so they only store the
134 Since most integers used in a compiler are small values, it is
135 generally profitable to use a representation of the value that is
136 as small as possible. LEN is used to indicate the number of
137 elements of the vector that are in use. The numbers are stored as
138 sign extended numbers as a means of compression. Leading
139 HOST_WIDE_INTs that contain strings of either -1 or 0 are removed
140 as long as they can be reconstructed from the top bit that is being
143 The precision and length of a wide_int are always greater than 0.
144 Any bits in a wide_int above the precision are sign-extended from the
145 most significant bit. For example, a 4-bit value 0x8 is represented as
146 VAL = { 0xf...fff8 }. However, as an optimization, we allow other integer
147 constants to be represented with undefined bits above the precision.
148 This allows INTEGER_CSTs to be pre-extended according to TYPE_SIGN,
149 so that the INTEGER_CST representation can be used both in TYPE_PRECISION
150 and in wider precisions.
152 There are constructors to create the various forms of wide_int from
153 trees, rtl and constants. For trees the options are:
156 wi::to_wide (t) // Treat T as a wide_int
157 wi::to_offset (t) // Treat T as an offset_int
158 wi::to_widest (t) // Treat T as a widest_int
160 All three are light-weight accessors that should have no overhead
161 in release builds. If it is useful for readability reasons to
162 store the result in a temporary variable, the preferred method is:
164 wi::tree_to_wide_ref twide = wi::to_wide (t);
165 wi::tree_to_offset_ref toffset = wi::to_offset (t);
166 wi::tree_to_widest_ref twidest = wi::to_widest (t);
168 To make an rtx into a wide_int, you have to pair it with a mode.
169 The canonical way to do this is with rtx_mode_t as in:
172 wide_int x = rtx_mode_t (r, mode);
174 Similarly, a wide_int can only be constructed from a host value if
175 the target precision is given explicitly, such as in:
177 wide_int x = wi::shwi (c, prec); // sign-extend C if necessary
178 wide_int y = wi::uhwi (c, prec); // zero-extend C if necessary
180 However, offset_int and widest_int have an inherent precision and so
181 can be initialized directly from a host value:
183 offset_int x = (int) c; // sign-extend C
184 widest_int x = (unsigned int) c; // zero-extend C
186 It is also possible to do arithmetic directly on rtx_mode_ts and
187 constants. For example:
189 wi::add (r1, r2); // add equal-sized rtx_mode_ts r1 and r2
190 wi::add (r1, 1); // add 1 to rtx_mode_t r1
191 wi::lshift (1, 100); // 1 << 100 as a widest_int
193 Many binary operations place restrictions on the combinations of inputs,
194 using the following rules:
196 - {rtx, wide_int} op {rtx, wide_int} -> wide_int
197 The inputs must be the same precision. The result is a wide_int
198 of the same precision
200 - {rtx, wide_int} op (un)signed HOST_WIDE_INT -> wide_int
201 (un)signed HOST_WIDE_INT op {rtx, wide_int} -> wide_int
202 The HOST_WIDE_INT is extended or truncated to the precision of
203 the other input. The result is a wide_int of the same precision
206 - (un)signed HOST_WIDE_INT op (un)signed HOST_WIDE_INT -> widest_int
207 The inputs are extended to widest_int precision and produce a
210 - offset_int op offset_int -> offset_int
211 offset_int op (un)signed HOST_WIDE_INT -> offset_int
212 (un)signed HOST_WIDE_INT op offset_int -> offset_int
214 - widest_int op widest_int -> widest_int
215 widest_int op (un)signed HOST_WIDE_INT -> widest_int
216 (un)signed HOST_WIDE_INT op widest_int -> widest_int
218 Other combinations like:
220 - widest_int op offset_int and
221 - wide_int op offset_int
223 are not allowed. The inputs should instead be extended or truncated
226 The inputs to comparison functions like wi::eq_p and wi::lts_p
227 follow the same compatibility rules, although their return types
228 are different. Unary functions on X produce the same result as
229 a binary operation X + X. Shift functions X op Y also produce
230 the same result as X + X; the precision of the shift amount Y
231 can be arbitrarily different from X. */
233 /* The MAX_BITSIZE_MODE_ANY_INT is automatically generated by a very
234 early examination of the target's mode file. The WIDE_INT_MAX_ELTS
235 can accomodate at least 1 more bit so that unsigned numbers of that
236 mode can be represented as a signed value. Note that it is still
237 possible to create fixed_wide_ints that have precisions greater than
238 MAX_BITSIZE_MODE_ANY_INT. This can be useful when representing a
239 double-width multiplication result, for example. */
240 #define WIDE_INT_MAX_ELTS \
241 ((MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT) / HOST_BITS_PER_WIDE_INT)
243 #define WIDE_INT_MAX_PRECISION (WIDE_INT_MAX_ELTS * HOST_BITS_PER_WIDE_INT)
245 /* This is the max size of any pointer on any machine. It does not
246 seem to be as easy to sniff this out of the machine description as
247 it is for MAX_BITSIZE_MODE_ANY_INT since targets may support
248 multiple address sizes and may have different address sizes for
249 different address spaces. However, currently the largest pointer
250 on any platform is 64 bits. When that changes, then it is likely
251 that a target hook should be defined so that targets can make this
252 value larger for those targets. */
253 #define ADDR_MAX_BITSIZE 64
255 /* This is the internal precision used when doing any address
256 arithmetic. The '4' is really 3 + 1. Three of the bits are for
257 the number of extra bits needed to do bit addresses and the other bit
258 is to allow everything to be signed without loosing any precision.
259 Then everything is rounded up to the next HWI for efficiency. */
260 #define ADDR_MAX_PRECISION \
261 ((ADDR_MAX_BITSIZE + 4 + HOST_BITS_PER_WIDE_INT - 1) \
262 & ~(HOST_BITS_PER_WIDE_INT - 1))
264 /* The number of HWIs needed to store an offset_int. */
265 #define OFFSET_INT_ELTS (ADDR_MAX_PRECISION / HOST_BITS_PER_WIDE_INT)
267 /* The type of result produced by a binary operation on types T1 and T2.
268 Defined purely for brevity. */
269 #define WI_BINARY_RESULT(T1, T2) \
270 typename wi::binary_traits <T1, T2>::result_type
272 /* Likewise for binary operators, which excludes the case in which neither
273 T1 nor T2 is a wide-int-based type. */
274 #define WI_BINARY_OPERATOR_RESULT(T1, T2) \
275 typename wi::binary_traits <T1, T2>::operator_result
277 /* The type of result produced by T1 << T2. Leads to substitution failure
278 if the operation isn't supported. Defined purely for brevity. */
279 #define WI_SIGNED_SHIFT_RESULT(T1, T2) \
280 typename wi::binary_traits <T1, T2>::signed_shift_result_type
282 /* The type of result produced by a sign-agnostic binary predicate on
283 types T1 and T2. This is bool if wide-int operations make sense for
284 T1 and T2 and leads to substitution failure otherwise. */
285 #define WI_BINARY_PREDICATE_RESULT(T1, T2) \
286 typename wi::binary_traits <T1, T2>::predicate_result
288 /* The type of result produced by a signed binary predicate on types T1 and T2.
289 This is bool if signed comparisons make sense for T1 and T2 and leads to
290 substitution failure otherwise. */
291 #define WI_SIGNED_BINARY_PREDICATE_RESULT(T1, T2) \
292 typename wi::binary_traits <T1, T2>::signed_predicate_result
294 /* The type of result produced by a unary operation on type T. */
295 #define WI_UNARY_RESULT(T) \
296 typename wi::binary_traits <T, T>::result_type
298 /* Define a variable RESULT to hold the result of a binary operation on
299 X and Y, which have types T1 and T2 respectively. Define VAL to
300 point to the blocks of RESULT. Once the user of the macro has
301 filled in VAL, it should call RESULT.set_len to set the number
302 of initialized blocks. */
303 #define WI_BINARY_RESULT_VAR(RESULT, VAL, T1, X, T2, Y) \
304 WI_BINARY_RESULT (T1, T2) RESULT = \
305 wi::int_traits <WI_BINARY_RESULT (T1, T2)>::get_binary_result (X, Y); \
306 HOST_WIDE_INT *VAL = RESULT.write_val ()
308 /* Similar for the result of a unary operation on X, which has type T. */
309 #define WI_UNARY_RESULT_VAR(RESULT, VAL, T, X) \
310 WI_UNARY_RESULT (T) RESULT = \
311 wi::int_traits <WI_UNARY_RESULT (T)>::get_binary_result (X, X); \
312 HOST_WIDE_INT *VAL = RESULT.write_val ()
314 template <typename T> class generic_wide_int;
315 template <int N> class fixed_wide_int_storage;
316 class wide_int_storage;
318 /* An N-bit integer. Until we can use typedef templates, use this instead. */
319 #define FIXED_WIDE_INT(N) \
320 generic_wide_int < fixed_wide_int_storage <N> >
322 typedef generic_wide_int <wide_int_storage> wide_int;
323 typedef FIXED_WIDE_INT (ADDR_MAX_PRECISION) offset_int;
324 typedef FIXED_WIDE_INT (WIDE_INT_MAX_PRECISION) widest_int;
325 /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
326 so as not to confuse gengtype. */
327 typedef generic_wide_int < fixed_wide_int_storage <WIDE_INT_MAX_PRECISION * 2> > widest2_int;
329 /* wi::storage_ref can be a reference to a primitive type,
330 so this is the conservatively-correct setting. */
331 template <bool SE, bool HDP = true>
332 class wide_int_ref_storage;
334 typedef generic_wide_int <wide_int_ref_storage <false> > wide_int_ref;
336 /* This can be used instead of wide_int_ref if the referenced value is
337 known to have type T. It carries across properties of T's representation,
338 such as whether excess upper bits in a HWI are defined, and can therefore
339 help avoid redundant work.
341 The macro could be replaced with a template typedef, once we're able
343 #define WIDE_INT_REF_FOR(T) \
345 <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, \
346 wi::int_traits <T>::host_dependent_precision> >
350 /* Operations that calculate overflow do so even for
351 TYPE_OVERFLOW_WRAPS types. For example, adding 1 to +MAX_INT in
352 an unsigned int is 0 and does not overflow in C/C++, but wi::add
353 will set the overflow argument in case it's needed for further
356 For operations that require overflow, these are the different
357 types of overflow. */
362 /* There was an overflow, but we are unsure whether it was an
363 overflow or an underflow. */
367 /* Classifies an integer based on its precision. */
368 enum precision_type {
369 /* The integer has both a precision and defined signedness. This allows
370 the integer to be converted to any width, since we know whether to fill
371 any extra bits with zeros or signs. */
374 /* The integer has a variable precision but no defined signedness. */
377 /* The integer has a constant precision (known at GCC compile time)
382 /* This class, which has no default implementation, is expected to
383 provide the following members:
385 static const enum precision_type precision_type;
386 Classifies the type of T.
388 static const unsigned int precision;
389 Only defined if precision_type == CONST_PRECISION. Specifies the
390 precision of all integers of type T.
392 static const bool host_dependent_precision;
393 True if the precision of T depends (or can depend) on the host.
395 static unsigned int get_precision (const T &x)
396 Return the number of bits in X.
398 static wi::storage_ref *decompose (HOST_WIDE_INT *scratch,
399 unsigned int precision, const T &x)
400 Decompose X as a PRECISION-bit integer, returning the associated
401 wi::storage_ref. SCRATCH is available as scratch space if needed.
402 The routine should assert that PRECISION is acceptable. */
403 template <typename T> struct int_traits;
405 /* This class provides a single type, result_type, which specifies the
406 type of integer produced by a binary operation whose inputs have
407 types T1 and T2. The definition should be symmetric. */
408 template <typename T1, typename T2,
409 enum precision_type P1 = int_traits <T1>::precision_type,
410 enum precision_type P2 = int_traits <T2>::precision_type>
411 struct binary_traits;
413 /* Specify the result type for each supported combination of binary
414 inputs. Note that CONST_PRECISION and VAR_PRECISION cannot be
415 mixed, in order to give stronger type checking. When both inputs
416 are CONST_PRECISION, they must have the same precision. */
417 template <typename T1, typename T2>
418 struct binary_traits <T1, T2, FLEXIBLE_PRECISION, FLEXIBLE_PRECISION>
420 typedef widest_int result_type;
421 /* Don't define operators for this combination. */
424 template <typename T1, typename T2>
425 struct binary_traits <T1, T2, FLEXIBLE_PRECISION, VAR_PRECISION>
427 typedef wide_int result_type;
428 typedef result_type operator_result;
429 typedef bool predicate_result;
432 template <typename T1, typename T2>
433 struct binary_traits <T1, T2, FLEXIBLE_PRECISION, CONST_PRECISION>
435 /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
436 so as not to confuse gengtype. */
437 typedef generic_wide_int < fixed_wide_int_storage
438 <int_traits <T2>::precision> > result_type;
439 typedef result_type operator_result;
440 typedef bool predicate_result;
441 typedef result_type signed_shift_result_type;
442 typedef bool signed_predicate_result;
445 template <typename T1, typename T2>
446 struct binary_traits <T1, T2, VAR_PRECISION, FLEXIBLE_PRECISION>
448 typedef wide_int result_type;
449 typedef result_type operator_result;
450 typedef bool predicate_result;
453 template <typename T1, typename T2>
454 struct binary_traits <T1, T2, CONST_PRECISION, FLEXIBLE_PRECISION>
456 /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
457 so as not to confuse gengtype. */
458 typedef generic_wide_int < fixed_wide_int_storage
459 <int_traits <T1>::precision> > result_type;
460 typedef result_type operator_result;
461 typedef bool predicate_result;
462 typedef result_type signed_shift_result_type;
463 typedef bool signed_predicate_result;
466 template <typename T1, typename T2>
467 struct binary_traits <T1, T2, CONST_PRECISION, CONST_PRECISION>
469 STATIC_ASSERT (int_traits <T1>::precision == int_traits <T2>::precision);
470 /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
471 so as not to confuse gengtype. */
472 typedef generic_wide_int < fixed_wide_int_storage
473 <int_traits <T1>::precision> > result_type;
474 typedef result_type operator_result;
475 typedef bool predicate_result;
476 typedef result_type signed_shift_result_type;
477 typedef bool signed_predicate_result;
480 template <typename T1, typename T2>
481 struct binary_traits <T1, T2, VAR_PRECISION, VAR_PRECISION>
483 typedef wide_int result_type;
484 typedef result_type operator_result;
485 typedef bool predicate_result;
489 /* Public functions for querying and operating on integers. */
492 template <typename T>
493 unsigned int get_precision (const T &);
495 template <typename T1, typename T2>
496 unsigned int get_binary_precision (const T1 &, const T2 &);
498 template <typename T1, typename T2>
499 void copy (T1 &, const T2 &);
501 #define UNARY_PREDICATE \
502 template <typename T> bool
503 #define UNARY_FUNCTION \
504 template <typename T> WI_UNARY_RESULT (T)
505 #define BINARY_PREDICATE \
506 template <typename T1, typename T2> bool
507 #define BINARY_FUNCTION \
508 template <typename T1, typename T2> WI_BINARY_RESULT (T1, T2)
509 #define SHIFT_FUNCTION \
510 template <typename T1, typename T2> WI_UNARY_RESULT (T1)
512 UNARY_PREDICATE fits_shwi_p (const T &);
513 UNARY_PREDICATE fits_uhwi_p (const T &);
514 UNARY_PREDICATE neg_p (const T &, signop = SIGNED);
516 template <typename T>
517 HOST_WIDE_INT sign_mask (const T &);
519 BINARY_PREDICATE eq_p (const T1 &, const T2 &);
520 BINARY_PREDICATE ne_p (const T1 &, const T2 &);
521 BINARY_PREDICATE lt_p (const T1 &, const T2 &, signop);
522 BINARY_PREDICATE lts_p (const T1 &, const T2 &);
523 BINARY_PREDICATE ltu_p (const T1 &, const T2 &);
524 BINARY_PREDICATE le_p (const T1 &, const T2 &, signop);
525 BINARY_PREDICATE les_p (const T1 &, const T2 &);
526 BINARY_PREDICATE leu_p (const T1 &, const T2 &);
527 BINARY_PREDICATE gt_p (const T1 &, const T2 &, signop);
528 BINARY_PREDICATE gts_p (const T1 &, const T2 &);
529 BINARY_PREDICATE gtu_p (const T1 &, const T2 &);
530 BINARY_PREDICATE ge_p (const T1 &, const T2 &, signop);
531 BINARY_PREDICATE ges_p (const T1 &, const T2 &);
532 BINARY_PREDICATE geu_p (const T1 &, const T2 &);
534 template <typename T1, typename T2>
535 int cmp (const T1 &, const T2 &, signop);
537 template <typename T1, typename T2>
538 int cmps (const T1 &, const T2 &);
540 template <typename T1, typename T2>
541 int cmpu (const T1 &, const T2 &);
543 UNARY_FUNCTION bit_not (const T &);
544 UNARY_FUNCTION neg (const T &);
545 UNARY_FUNCTION neg (const T &, overflow_type *);
546 UNARY_FUNCTION abs (const T &);
547 UNARY_FUNCTION ext (const T &, unsigned int, signop);
548 UNARY_FUNCTION sext (const T &, unsigned int);
549 UNARY_FUNCTION zext (const T &, unsigned int);
550 UNARY_FUNCTION set_bit (const T &, unsigned int);
552 BINARY_FUNCTION min (const T1 &, const T2 &, signop);
553 BINARY_FUNCTION smin (const T1 &, const T2 &);
554 BINARY_FUNCTION umin (const T1 &, const T2 &);
555 BINARY_FUNCTION max (const T1 &, const T2 &, signop);
556 BINARY_FUNCTION smax (const T1 &, const T2 &);
557 BINARY_FUNCTION umax (const T1 &, const T2 &);
559 BINARY_FUNCTION bit_and (const T1 &, const T2 &);
560 BINARY_FUNCTION bit_and_not (const T1 &, const T2 &);
561 BINARY_FUNCTION bit_or (const T1 &, const T2 &);
562 BINARY_FUNCTION bit_or_not (const T1 &, const T2 &);
563 BINARY_FUNCTION bit_xor (const T1 &, const T2 &);
564 BINARY_FUNCTION add (const T1 &, const T2 &);
565 BINARY_FUNCTION add (const T1 &, const T2 &, signop, overflow_type *);
566 BINARY_FUNCTION sub (const T1 &, const T2 &);
567 BINARY_FUNCTION sub (const T1 &, const T2 &, signop, overflow_type *);
568 BINARY_FUNCTION mul (const T1 &, const T2 &);
569 BINARY_FUNCTION mul (const T1 &, const T2 &, signop, overflow_type *);
570 BINARY_FUNCTION smul (const T1 &, const T2 &, overflow_type *);
571 BINARY_FUNCTION umul (const T1 &, const T2 &, overflow_type *);
572 BINARY_FUNCTION mul_high (const T1 &, const T2 &, signop);
573 BINARY_FUNCTION div_trunc (const T1 &, const T2 &, signop,
574 overflow_type * = 0);
575 BINARY_FUNCTION sdiv_trunc (const T1 &, const T2 &);
576 BINARY_FUNCTION udiv_trunc (const T1 &, const T2 &);
577 BINARY_FUNCTION div_floor (const T1 &, const T2 &, signop,
578 overflow_type * = 0);
579 BINARY_FUNCTION udiv_floor (const T1 &, const T2 &);
580 BINARY_FUNCTION sdiv_floor (const T1 &, const T2 &);
581 BINARY_FUNCTION div_ceil (const T1 &, const T2 &, signop,
582 overflow_type * = 0);
583 BINARY_FUNCTION udiv_ceil (const T1 &, const T2 &);
584 BINARY_FUNCTION div_round (const T1 &, const T2 &, signop,
585 overflow_type * = 0);
586 BINARY_FUNCTION divmod_trunc (const T1 &, const T2 &, signop,
587 WI_BINARY_RESULT (T1, T2) *);
588 BINARY_FUNCTION gcd (const T1 &, const T2 &, signop = UNSIGNED);
589 BINARY_FUNCTION mod_trunc (const T1 &, const T2 &, signop,
590 overflow_type * = 0);
591 BINARY_FUNCTION smod_trunc (const T1 &, const T2 &);
592 BINARY_FUNCTION umod_trunc (const T1 &, const T2 &);
593 BINARY_FUNCTION mod_floor (const T1 &, const T2 &, signop,
594 overflow_type * = 0);
595 BINARY_FUNCTION umod_floor (const T1 &, const T2 &);
596 BINARY_FUNCTION mod_ceil (const T1 &, const T2 &, signop,
597 overflow_type * = 0);
598 BINARY_FUNCTION mod_round (const T1 &, const T2 &, signop,
599 overflow_type * = 0);
601 template <typename T1, typename T2>
602 bool multiple_of_p (const T1 &, const T2 &, signop);
604 template <typename T1, typename T2>
605 bool multiple_of_p (const T1 &, const T2 &, signop,
606 WI_BINARY_RESULT (T1, T2) *);
608 SHIFT_FUNCTION lshift (const T1 &, const T2 &);
609 SHIFT_FUNCTION lrshift (const T1 &, const T2 &);
610 SHIFT_FUNCTION arshift (const T1 &, const T2 &);
611 SHIFT_FUNCTION rshift (const T1 &, const T2 &, signop sgn);
612 SHIFT_FUNCTION lrotate (const T1 &, const T2 &, unsigned int = 0);
613 SHIFT_FUNCTION rrotate (const T1 &, const T2 &, unsigned int = 0);
615 #undef SHIFT_FUNCTION
616 #undef BINARY_PREDICATE
617 #undef BINARY_FUNCTION
618 #undef UNARY_PREDICATE
619 #undef UNARY_FUNCTION
621 bool only_sign_bit_p (const wide_int_ref &, unsigned int);
622 bool only_sign_bit_p (const wide_int_ref &);
623 int clz (const wide_int_ref &);
624 int clrsb (const wide_int_ref &);
625 int ctz (const wide_int_ref &);
626 int exact_log2 (const wide_int_ref &);
627 int floor_log2 (const wide_int_ref &);
628 int ffs (const wide_int_ref &);
629 int popcount (const wide_int_ref &);
630 int parity (const wide_int_ref &);
632 template <typename T>
633 unsigned HOST_WIDE_INT extract_uhwi (const T &, unsigned int, unsigned int);
635 template <typename T>
636 unsigned int min_precision (const T &, signop);
638 static inline void accumulate_overflow (overflow_type &, overflow_type);
643 /* Contains the components of a decomposed integer for easy, direct
649 storage_ref (const HOST_WIDE_INT *, unsigned int, unsigned int);
651 const HOST_WIDE_INT *val;
653 unsigned int precision;
655 /* Provide enough trappings for this class to act as storage for
657 unsigned int get_len () const;
658 unsigned int get_precision () const;
659 const HOST_WIDE_INT *get_val () const;
663 inline::wi::storage_ref::storage_ref (const HOST_WIDE_INT *val_in,
665 unsigned int precision_in)
666 : val (val_in), len (len_in), precision (precision_in)
671 wi::storage_ref::get_len () const
677 wi::storage_ref::get_precision () const
682 inline const HOST_WIDE_INT *
683 wi::storage_ref::get_val () const
688 /* This class defines an integer type using the storage provided by the
689 template argument. The storage class must provide the following
692 unsigned int get_precision () const
693 Return the number of bits in the integer.
695 HOST_WIDE_INT *get_val () const
696 Return a pointer to the array of blocks that encodes the integer.
698 unsigned int get_len () const
699 Return the number of blocks in get_val (). If this is smaller
700 than the number of blocks implied by get_precision (), the
701 remaining blocks are sign extensions of block get_len () - 1.
703 Although not required by generic_wide_int itself, writable storage
704 classes can also provide the following functions:
706 HOST_WIDE_INT *write_val ()
707 Get a modifiable version of get_val ()
709 unsigned int set_len (unsigned int len)
710 Set the value returned by get_len () to LEN. */
711 template <typename storage>
712 class GTY(()) generic_wide_int : public storage
717 template <typename T>
718 generic_wide_int (const T &);
720 template <typename T>
721 generic_wide_int (const T &, unsigned int);
724 HOST_WIDE_INT to_shwi (unsigned int) const;
725 HOST_WIDE_INT to_shwi () const;
726 unsigned HOST_WIDE_INT to_uhwi (unsigned int) const;
727 unsigned HOST_WIDE_INT to_uhwi () const;
728 HOST_WIDE_INT to_short_addr () const;
730 /* Public accessors for the interior of a wide int. */
731 HOST_WIDE_INT sign_mask () const;
732 HOST_WIDE_INT elt (unsigned int) const;
733 HOST_WIDE_INT sext_elt (unsigned int) const;
734 unsigned HOST_WIDE_INT ulow () const;
735 unsigned HOST_WIDE_INT uhigh () const;
736 HOST_WIDE_INT slow () const;
737 HOST_WIDE_INT shigh () const;
739 template <typename T>
740 generic_wide_int &operator = (const T &);
742 #define ASSIGNMENT_OPERATOR(OP, F) \
743 template <typename T> \
744 generic_wide_int &OP (const T &c) { return (*this = wi::F (*this, c)); }
746 /* Restrict these to cases where the shift operator is defined. */
747 #define SHIFT_ASSIGNMENT_OPERATOR(OP, OP2) \
748 template <typename T> \
749 generic_wide_int &OP (const T &c) { return (*this = *this OP2 c); }
751 #define INCDEC_OPERATOR(OP, DELTA) \
752 generic_wide_int &OP () { *this += DELTA; return *this; }
754 ASSIGNMENT_OPERATOR (operator &=, bit_and)
755 ASSIGNMENT_OPERATOR (operator |=, bit_or)
756 ASSIGNMENT_OPERATOR (operator ^=, bit_xor)
757 ASSIGNMENT_OPERATOR (operator +=, add)
758 ASSIGNMENT_OPERATOR (operator -=, sub)
759 ASSIGNMENT_OPERATOR (operator *=, mul)
760 ASSIGNMENT_OPERATOR (operator <<=, lshift)
761 SHIFT_ASSIGNMENT_OPERATOR (operator >>=, >>)
762 INCDEC_OPERATOR (operator ++, 1)
763 INCDEC_OPERATOR (operator --, -1)
765 #undef SHIFT_ASSIGNMENT_OPERATOR
766 #undef ASSIGNMENT_OPERATOR
767 #undef INCDEC_OPERATOR
769 /* Debugging functions. */
772 static const bool is_sign_extended
773 = wi::int_traits <generic_wide_int <storage> >::is_sign_extended;
776 template <typename storage>
777 inline generic_wide_int <storage>::generic_wide_int () {}
779 template <typename storage>
780 template <typename T>
781 inline generic_wide_int <storage>::generic_wide_int (const T &x)
786 template <typename storage>
787 template <typename T>
788 inline generic_wide_int <storage>::generic_wide_int (const T &x,
789 unsigned int precision)
790 : storage (x, precision)
794 /* Return THIS as a signed HOST_WIDE_INT, sign-extending from PRECISION.
795 If THIS does not fit in PRECISION, the information is lost. */
796 template <typename storage>
798 generic_wide_int <storage>::to_shwi (unsigned int precision) const
800 if (precision < HOST_BITS_PER_WIDE_INT)
801 return sext_hwi (this->get_val ()[0], precision);
803 return this->get_val ()[0];
806 /* Return THIS as a signed HOST_WIDE_INT, in its natural precision. */
807 template <typename storage>
809 generic_wide_int <storage>::to_shwi () const
811 if (is_sign_extended)
812 return this->get_val ()[0];
814 return to_shwi (this->get_precision ());
817 /* Return THIS as an unsigned HOST_WIDE_INT, zero-extending from
818 PRECISION. If THIS does not fit in PRECISION, the information
820 template <typename storage>
821 inline unsigned HOST_WIDE_INT
822 generic_wide_int <storage>::to_uhwi (unsigned int precision) const
824 if (precision < HOST_BITS_PER_WIDE_INT)
825 return zext_hwi (this->get_val ()[0], precision);
827 return this->get_val ()[0];
830 /* Return THIS as an signed HOST_WIDE_INT, in its natural precision. */
831 template <typename storage>
832 inline unsigned HOST_WIDE_INT
833 generic_wide_int <storage>::to_uhwi () const
835 return to_uhwi (this->get_precision ());
838 /* TODO: The compiler is half converted from using HOST_WIDE_INT to
839 represent addresses to using offset_int to represent addresses.
840 We use to_short_addr at the interface from new code to old,
842 template <typename storage>
844 generic_wide_int <storage>::to_short_addr () const
846 return this->get_val ()[0];
849 /* Return the implicit value of blocks above get_len (). */
850 template <typename storage>
852 generic_wide_int <storage>::sign_mask () const
854 unsigned int len = this->get_len ();
855 gcc_assert (len > 0);
857 unsigned HOST_WIDE_INT high = this->get_val ()[len - 1];
858 if (!is_sign_extended)
860 unsigned int precision = this->get_precision ();
861 int excess = len * HOST_BITS_PER_WIDE_INT - precision;
865 return (HOST_WIDE_INT) (high) < 0 ? -1 : 0;
868 /* Return the signed value of the least-significant explicitly-encoded
870 template <typename storage>
872 generic_wide_int <storage>::slow () const
874 return this->get_val ()[0];
877 /* Return the signed value of the most-significant explicitly-encoded
879 template <typename storage>
881 generic_wide_int <storage>::shigh () const
883 return this->get_val ()[this->get_len () - 1];
886 /* Return the unsigned value of the least-significant
887 explicitly-encoded block. */
888 template <typename storage>
889 inline unsigned HOST_WIDE_INT
890 generic_wide_int <storage>::ulow () const
892 return this->get_val ()[0];
895 /* Return the unsigned value of the most-significant
896 explicitly-encoded block. */
897 template <typename storage>
898 inline unsigned HOST_WIDE_INT
899 generic_wide_int <storage>::uhigh () const
901 return this->get_val ()[this->get_len () - 1];
904 /* Return block I, which might be implicitly or explicit encoded. */
905 template <typename storage>
907 generic_wide_int <storage>::elt (unsigned int i) const
909 if (i >= this->get_len ())
912 return this->get_val ()[i];
915 /* Like elt, but sign-extend beyond the upper bit, instead of returning
917 template <typename storage>
919 generic_wide_int <storage>::sext_elt (unsigned int i) const
921 HOST_WIDE_INT elt_i = elt (i);
922 if (!is_sign_extended)
924 unsigned int precision = this->get_precision ();
925 unsigned int lsb = i * HOST_BITS_PER_WIDE_INT;
926 if (precision - lsb < HOST_BITS_PER_WIDE_INT)
927 elt_i = sext_hwi (elt_i, precision - lsb);
932 template <typename storage>
933 template <typename T>
934 inline generic_wide_int <storage> &
935 generic_wide_int <storage>::operator = (const T &x)
937 storage::operator = (x);
941 /* Dump the contents of the integer to stderr, for debugging. */
942 template <typename storage>
944 generic_wide_int <storage>::dump () const
946 unsigned int len = this->get_len ();
947 const HOST_WIDE_INT *val = this->get_val ();
948 unsigned int precision = this->get_precision ();
949 fprintf (stderr, "[");
950 if (len * HOST_BITS_PER_WIDE_INT < precision)
951 fprintf (stderr, "...,");
952 for (unsigned int i = 0; i < len - 1; ++i)
953 fprintf (stderr, HOST_WIDE_INT_PRINT_HEX ",", val[len - 1 - i]);
954 fprintf (stderr, HOST_WIDE_INT_PRINT_HEX "], precision = %d\n",
960 template <typename storage>
961 struct int_traits < generic_wide_int <storage> >
962 : public wi::int_traits <storage>
964 static unsigned int get_precision (const generic_wide_int <storage> &);
965 static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int,
966 const generic_wide_int <storage> &);
970 template <typename storage>
972 wi::int_traits < generic_wide_int <storage> >::
973 get_precision (const generic_wide_int <storage> &x)
975 return x.get_precision ();
978 template <typename storage>
979 inline wi::storage_ref
980 wi::int_traits < generic_wide_int <storage> >::
981 decompose (HOST_WIDE_INT *, unsigned int precision,
982 const generic_wide_int <storage> &x)
984 gcc_checking_assert (precision == x.get_precision ());
985 return wi::storage_ref (x.get_val (), x.get_len (), precision);
988 /* Provide the storage for a wide_int_ref. This acts like a read-only
989 wide_int, with the optimization that VAL is normally a pointer to
990 another integer's storage, so that no array copy is needed. */
991 template <bool SE, bool HDP>
992 class wide_int_ref_storage : public wi::storage_ref
995 /* Scratch space that can be used when decomposing the original integer.
996 It must live as long as this object. */
997 HOST_WIDE_INT scratch[2];
1000 wide_int_ref_storage () {}
1002 wide_int_ref_storage (const wi::storage_ref &);
1004 template <typename T>
1005 wide_int_ref_storage (const T &);
1007 template <typename T>
1008 wide_int_ref_storage (const T &, unsigned int);
1011 /* Create a reference from an existing reference. */
1012 template <bool SE, bool HDP>
1013 inline wide_int_ref_storage <SE, HDP>::
1014 wide_int_ref_storage (const wi::storage_ref &x)
1018 /* Create a reference to integer X in its natural precision. Note
1019 that the natural precision is host-dependent for primitive
1021 template <bool SE, bool HDP>
1022 template <typename T>
1023 inline wide_int_ref_storage <SE, HDP>::wide_int_ref_storage (const T &x)
1024 : storage_ref (wi::int_traits <T>::decompose (scratch,
1025 wi::get_precision (x), x))
1029 /* Create a reference to integer X in precision PRECISION. */
1030 template <bool SE, bool HDP>
1031 template <typename T>
1032 inline wide_int_ref_storage <SE, HDP>::
1033 wide_int_ref_storage (const T &x, unsigned int precision)
1034 : storage_ref (wi::int_traits <T>::decompose (scratch, precision, x))
1040 template <bool SE, bool HDP>
1041 struct int_traits <wide_int_ref_storage <SE, HDP> >
1043 static const enum precision_type precision_type = VAR_PRECISION;
1044 static const bool host_dependent_precision = HDP;
1045 static const bool is_sign_extended = SE;
1051 unsigned int force_to_size (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1052 unsigned int, unsigned int, unsigned int,
1054 unsigned int from_array (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1055 unsigned int, unsigned int, bool = true);
1058 /* The storage used by wide_int. */
1059 class GTY(()) wide_int_storage
1062 HOST_WIDE_INT val[WIDE_INT_MAX_ELTS];
1064 unsigned int precision;
1067 wide_int_storage ();
1068 template <typename T>
1069 wide_int_storage (const T &);
1071 /* The standard generic_wide_int storage methods. */
1072 unsigned int get_precision () const;
1073 const HOST_WIDE_INT *get_val () const;
1074 unsigned int get_len () const;
1075 HOST_WIDE_INT *write_val ();
1076 void set_len (unsigned int, bool = false);
1078 template <typename T>
1079 wide_int_storage &operator = (const T &);
1081 static wide_int from (const wide_int_ref &, unsigned int, signop);
1082 static wide_int from_array (const HOST_WIDE_INT *, unsigned int,
1083 unsigned int, bool = true);
1084 static wide_int create (unsigned int);
1086 /* FIXME: target-dependent, so should disappear. */
1087 wide_int bswap () const;
1093 struct int_traits <wide_int_storage>
1095 static const enum precision_type precision_type = VAR_PRECISION;
1096 /* Guaranteed by a static assert in the wide_int_storage constructor. */
1097 static const bool host_dependent_precision = false;
1098 static const bool is_sign_extended = true;
1099 template <typename T1, typename T2>
1100 static wide_int get_binary_result (const T1 &, const T2 &);
1104 inline wide_int_storage::wide_int_storage () {}
1106 /* Initialize the storage from integer X, in its natural precision.
1107 Note that we do not allow integers with host-dependent precision
1108 to become wide_ints; wide_ints must always be logically independent
1110 template <typename T>
1111 inline wide_int_storage::wide_int_storage (const T &x)
1113 { STATIC_ASSERT (!wi::int_traits<T>::host_dependent_precision); }
1114 { STATIC_ASSERT (wi::int_traits<T>::precision_type != wi::CONST_PRECISION); }
1115 WIDE_INT_REF_FOR (T) xi (x);
1116 precision = xi.precision;
1117 wi::copy (*this, xi);
1120 template <typename T>
1121 inline wide_int_storage&
1122 wide_int_storage::operator = (const T &x)
1124 { STATIC_ASSERT (!wi::int_traits<T>::host_dependent_precision); }
1125 { STATIC_ASSERT (wi::int_traits<T>::precision_type != wi::CONST_PRECISION); }
1126 WIDE_INT_REF_FOR (T) xi (x);
1127 precision = xi.precision;
1128 wi::copy (*this, xi);
1133 wide_int_storage::get_precision () const
1138 inline const HOST_WIDE_INT *
1139 wide_int_storage::get_val () const
1145 wide_int_storage::get_len () const
1150 inline HOST_WIDE_INT *
1151 wide_int_storage::write_val ()
1157 wide_int_storage::set_len (unsigned int l, bool is_sign_extended)
1160 if (!is_sign_extended && len * HOST_BITS_PER_WIDE_INT > precision)
1161 val[len - 1] = sext_hwi (val[len - 1],
1162 precision % HOST_BITS_PER_WIDE_INT);
1165 /* Treat X as having signedness SGN and convert it to a PRECISION-bit
1168 wide_int_storage::from (const wide_int_ref &x, unsigned int precision,
1171 wide_int result = wide_int::create (precision);
1172 result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
1173 x.precision, precision, sgn));
1177 /* Create a wide_int from the explicit block encoding given by VAL and
1178 LEN. PRECISION is the precision of the integer. NEED_CANON_P is
1179 true if the encoding may have redundant trailing blocks. */
1181 wide_int_storage::from_array (const HOST_WIDE_INT *val, unsigned int len,
1182 unsigned int precision, bool need_canon_p)
1184 wide_int result = wide_int::create (precision);
1185 result.set_len (wi::from_array (result.write_val (), val, len, precision,
1190 /* Return an uninitialized wide_int with precision PRECISION. */
1192 wide_int_storage::create (unsigned int precision)
1195 x.precision = precision;
1199 template <typename T1, typename T2>
1201 wi::int_traits <wide_int_storage>::get_binary_result (const T1 &x, const T2 &y)
1203 /* This shouldn't be used for two flexible-precision inputs. */
1204 STATIC_ASSERT (wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION
1205 || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION);
1206 if (wi::int_traits <T1>::precision_type == FLEXIBLE_PRECISION)
1207 return wide_int::create (wi::get_precision (y));
1209 return wide_int::create (wi::get_precision (x));
1212 /* The storage used by FIXED_WIDE_INT (N). */
1214 class GTY(()) fixed_wide_int_storage
1217 HOST_WIDE_INT val[(N + HOST_BITS_PER_WIDE_INT + 1) / HOST_BITS_PER_WIDE_INT];
1221 fixed_wide_int_storage ();
1222 template <typename T>
1223 fixed_wide_int_storage (const T &);
1225 /* The standard generic_wide_int storage methods. */
1226 unsigned int get_precision () const;
1227 const HOST_WIDE_INT *get_val () const;
1228 unsigned int get_len () const;
1229 HOST_WIDE_INT *write_val ();
1230 void set_len (unsigned int, bool = false);
1232 static FIXED_WIDE_INT (N) from (const wide_int_ref &, signop);
1233 static FIXED_WIDE_INT (N) from_array (const HOST_WIDE_INT *, unsigned int,
1240 struct int_traits < fixed_wide_int_storage <N> >
1242 static const enum precision_type precision_type = CONST_PRECISION;
1243 static const bool host_dependent_precision = false;
1244 static const bool is_sign_extended = true;
1245 static const unsigned int precision = N;
1246 template <typename T1, typename T2>
1247 static FIXED_WIDE_INT (N) get_binary_result (const T1 &, const T2 &);
1252 inline fixed_wide_int_storage <N>::fixed_wide_int_storage () {}
1254 /* Initialize the storage from integer X, in precision N. */
1256 template <typename T>
1257 inline fixed_wide_int_storage <N>::fixed_wide_int_storage (const T &x)
1259 /* Check for type compatibility. We don't want to initialize a
1260 fixed-width integer from something like a wide_int. */
1261 WI_BINARY_RESULT (T, FIXED_WIDE_INT (N)) *assertion ATTRIBUTE_UNUSED;
1262 wi::copy (*this, WIDE_INT_REF_FOR (T) (x, N));
1267 fixed_wide_int_storage <N>::get_precision () const
1273 inline const HOST_WIDE_INT *
1274 fixed_wide_int_storage <N>::get_val () const
1281 fixed_wide_int_storage <N>::get_len () const
1287 inline HOST_WIDE_INT *
1288 fixed_wide_int_storage <N>::write_val ()
1295 fixed_wide_int_storage <N>::set_len (unsigned int l, bool)
1298 /* There are no excess bits in val[len - 1]. */
1299 STATIC_ASSERT (N % HOST_BITS_PER_WIDE_INT == 0);
1302 /* Treat X as having signedness SGN and convert it to an N-bit number. */
1304 inline FIXED_WIDE_INT (N)
1305 fixed_wide_int_storage <N>::from (const wide_int_ref &x, signop sgn)
1307 FIXED_WIDE_INT (N) result;
1308 result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
1309 x.precision, N, sgn));
1313 /* Create a FIXED_WIDE_INT (N) from the explicit block encoding given by
1314 VAL and LEN. NEED_CANON_P is true if the encoding may have redundant
1317 inline FIXED_WIDE_INT (N)
1318 fixed_wide_int_storage <N>::from_array (const HOST_WIDE_INT *val,
1322 FIXED_WIDE_INT (N) result;
1323 result.set_len (wi::from_array (result.write_val (), val, len,
1329 template <typename T1, typename T2>
1330 inline FIXED_WIDE_INT (N)
1331 wi::int_traits < fixed_wide_int_storage <N> >::
1332 get_binary_result (const T1 &, const T2 &)
1334 return FIXED_WIDE_INT (N) ();
1337 /* A reference to one element of a trailing_wide_ints structure. */
1338 class trailing_wide_int_storage
1341 /* The precision of the integer, which is a fixed property of the
1342 parent trailing_wide_ints. */
1343 unsigned int m_precision;
1345 /* A pointer to the length field. */
1346 unsigned char *m_len;
1348 /* A pointer to the HWI array. There are enough elements to hold all
1349 values of precision M_PRECISION. */
1350 HOST_WIDE_INT *m_val;
1353 trailing_wide_int_storage (unsigned int, unsigned char *, HOST_WIDE_INT *);
1355 /* The standard generic_wide_int storage methods. */
1356 unsigned int get_len () const;
1357 unsigned int get_precision () const;
1358 const HOST_WIDE_INT *get_val () const;
1359 HOST_WIDE_INT *write_val ();
1360 void set_len (unsigned int, bool = false);
1362 template <typename T>
1363 trailing_wide_int_storage &operator = (const T &);
1366 typedef generic_wide_int <trailing_wide_int_storage> trailing_wide_int;
1368 /* trailing_wide_int behaves like a wide_int. */
1372 struct int_traits <trailing_wide_int_storage>
1373 : public int_traits <wide_int_storage> {};
1376 /* A variable-length array of wide_int-like objects that can be put
1377 at the end of a variable-sized structure. The number of objects is
1378 at most N and can be set at runtime by using set_precision().
1380 Use extra_size to calculate how many bytes beyond the
1381 sizeof need to be allocated. Use set_precision to initialize the
1384 struct GTY((user)) trailing_wide_ints
1387 /* The shared precision of each number. */
1388 unsigned short m_precision;
1390 /* The shared maximum length of each number. */
1391 unsigned char m_max_len;
1393 /* The number of elements. */
1394 unsigned char m_num_elements;
1396 /* The current length of each number.
1397 Avoid char array so the whole structure is not a typeless storage
1398 that will, in turn, turn off TBAA on gimple, trees and RTL. */
1399 struct {unsigned char len;} m_len[N];
1401 /* The variable-length part of the structure, which always contains
1402 at least one HWI. Element I starts at index I * M_MAX_LEN. */
1403 HOST_WIDE_INT m_val[1];
1406 typedef WIDE_INT_REF_FOR (trailing_wide_int_storage) const_reference;
1408 void set_precision (unsigned int precision, unsigned int num_elements = N);
1409 unsigned int get_precision () const { return m_precision; }
1410 unsigned int num_elements () const { return m_num_elements; }
1411 trailing_wide_int operator [] (unsigned int);
1412 const_reference operator [] (unsigned int) const;
1413 static size_t extra_size (unsigned int precision,
1414 unsigned int num_elements = N);
1415 size_t extra_size () const { return extra_size (m_precision,
1419 inline trailing_wide_int_storage::
1420 trailing_wide_int_storage (unsigned int precision, unsigned char *len,
1422 : m_precision (precision), m_len (len), m_val (val)
1427 trailing_wide_int_storage::get_len () const
1433 trailing_wide_int_storage::get_precision () const
1438 inline const HOST_WIDE_INT *
1439 trailing_wide_int_storage::get_val () const
1444 inline HOST_WIDE_INT *
1445 trailing_wide_int_storage::write_val ()
1451 trailing_wide_int_storage::set_len (unsigned int len, bool is_sign_extended)
1454 if (!is_sign_extended && len * HOST_BITS_PER_WIDE_INT > m_precision)
1455 m_val[len - 1] = sext_hwi (m_val[len - 1],
1456 m_precision % HOST_BITS_PER_WIDE_INT);
1459 template <typename T>
1460 inline trailing_wide_int_storage &
1461 trailing_wide_int_storage::operator = (const T &x)
1463 WIDE_INT_REF_FOR (T) xi (x, m_precision);
1464 wi::copy (*this, xi);
1468 /* Initialize the structure and record that all elements have precision
1469 PRECISION. NUM_ELEMENTS can be no more than N. */
1472 trailing_wide_ints <N>::set_precision (unsigned int precision,
1473 unsigned int num_elements)
1475 gcc_checking_assert (num_elements <= N);
1476 m_num_elements = num_elements;
1477 m_precision = precision;
1478 m_max_len = ((precision + HOST_BITS_PER_WIDE_INT - 1)
1479 / HOST_BITS_PER_WIDE_INT);
1482 /* Return a reference to element INDEX. */
1484 inline trailing_wide_int
1485 trailing_wide_ints <N>::operator [] (unsigned int index)
1487 return trailing_wide_int_storage (m_precision, &m_len[index].len,
1488 &m_val[index * m_max_len]);
1492 inline typename trailing_wide_ints <N>::const_reference
1493 trailing_wide_ints <N>::operator [] (unsigned int index) const
1495 return wi::storage_ref (&m_val[index * m_max_len],
1496 m_len[index].len, m_precision);
1499 /* Return how many extra bytes need to be added to the end of the
1500 structure in order to handle NUM_ELEMENTS wide_ints of precision
1501 PRECISION. NUM_ELEMENTS is the number of elements, and defaults
1505 trailing_wide_ints <N>::extra_size (unsigned int precision,
1506 unsigned int num_elements)
1508 unsigned int max_len = ((precision + HOST_BITS_PER_WIDE_INT - 1)
1509 / HOST_BITS_PER_WIDE_INT);
1510 gcc_checking_assert (num_elements <= N);
1511 return (num_elements * max_len - 1) * sizeof (HOST_WIDE_INT);
1514 /* This macro is used in structures that end with a trailing_wide_ints field
1515 called FIELD. It declares get_NAME() and set_NAME() methods to access
1516 element I of FIELD. */
1517 #define TRAILING_WIDE_INT_ACCESSOR(NAME, FIELD, I) \
1518 trailing_wide_int get_##NAME () { return FIELD[I]; } \
1519 template <typename T> void set_##NAME (const T &x) { FIELD[I] = x; }
1523 /* Implementation of int_traits for primitive integer types like "int". */
1524 template <typename T, bool signed_p>
1525 struct primitive_int_traits
1527 static const enum precision_type precision_type = FLEXIBLE_PRECISION;
1528 static const bool host_dependent_precision = true;
1529 static const bool is_sign_extended = true;
1530 static unsigned int get_precision (T);
1531 static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int, T);
1535 template <typename T, bool signed_p>
1537 wi::primitive_int_traits <T, signed_p>::get_precision (T)
1539 return sizeof (T) * CHAR_BIT;
1542 template <typename T, bool signed_p>
1543 inline wi::storage_ref
1544 wi::primitive_int_traits <T, signed_p>::decompose (HOST_WIDE_INT *scratch,
1545 unsigned int precision, T x)
1548 if (signed_p || scratch[0] >= 0 || precision <= HOST_BITS_PER_WIDE_INT)
1549 return wi::storage_ref (scratch, 1, precision);
1551 return wi::storage_ref (scratch, 2, precision);
1554 /* Allow primitive C types to be used in wi:: routines. */
1558 struct int_traits <unsigned char>
1559 : public primitive_int_traits <unsigned char, false> {};
1562 struct int_traits <unsigned short>
1563 : public primitive_int_traits <unsigned short, false> {};
1566 struct int_traits <int>
1567 : public primitive_int_traits <int, true> {};
1570 struct int_traits <unsigned int>
1571 : public primitive_int_traits <unsigned int, false> {};
1574 struct int_traits <long>
1575 : public primitive_int_traits <long, true> {};
1578 struct int_traits <unsigned long>
1579 : public primitive_int_traits <unsigned long, false> {};
1581 #if defined HAVE_LONG_LONG
1583 struct int_traits <long long>
1584 : public primitive_int_traits <long long, true> {};
1587 struct int_traits <unsigned long long>
1588 : public primitive_int_traits <unsigned long long, false> {};
1594 /* Stores HWI-sized integer VAL, treating it as having signedness SGN
1595 and precision PRECISION. */
1600 hwi_with_prec (HOST_WIDE_INT, unsigned int, signop);
1602 unsigned int precision;
1606 hwi_with_prec shwi (HOST_WIDE_INT, unsigned int);
1607 hwi_with_prec uhwi (unsigned HOST_WIDE_INT, unsigned int);
1609 hwi_with_prec minus_one (unsigned int);
1610 hwi_with_prec zero (unsigned int);
1611 hwi_with_prec one (unsigned int);
1612 hwi_with_prec two (unsigned int);
1615 inline wi::hwi_with_prec::hwi_with_prec (HOST_WIDE_INT v, unsigned int p,
1617 : precision (p), sgn (s)
1619 if (precision < HOST_BITS_PER_WIDE_INT)
1620 val = sext_hwi (v, precision);
1625 /* Return a signed integer that has value VAL and precision PRECISION. */
1626 inline wi::hwi_with_prec
1627 wi::shwi (HOST_WIDE_INT val, unsigned int precision)
1629 return hwi_with_prec (val, precision, SIGNED);
1632 /* Return an unsigned integer that has value VAL and precision PRECISION. */
1633 inline wi::hwi_with_prec
1634 wi::uhwi (unsigned HOST_WIDE_INT val, unsigned int precision)
1636 return hwi_with_prec (val, precision, UNSIGNED);
1639 /* Return a wide int of -1 with precision PRECISION. */
1640 inline wi::hwi_with_prec
1641 wi::minus_one (unsigned int precision)
1643 return wi::shwi (-1, precision);
1646 /* Return a wide int of 0 with precision PRECISION. */
1647 inline wi::hwi_with_prec
1648 wi::zero (unsigned int precision)
1650 return wi::shwi (0, precision);
1653 /* Return a wide int of 1 with precision PRECISION. */
1654 inline wi::hwi_with_prec
1655 wi::one (unsigned int precision)
1657 return wi::shwi (1, precision);
1660 /* Return a wide int of 2 with precision PRECISION. */
1661 inline wi::hwi_with_prec
1662 wi::two (unsigned int precision)
1664 return wi::shwi (2, precision);
1669 /* ints_for<T>::zero (X) returns a zero that, when asssigned to a T,
1670 gives that T the same precision as X. */
1671 template<typename T, precision_type = int_traits<T>::precision_type>
1674 static int zero (const T &) { return 0; }
1677 template<typename T>
1678 struct ints_for<T, VAR_PRECISION>
1680 static hwi_with_prec zero (const T &);
1684 template<typename T>
1685 inline wi::hwi_with_prec
1686 wi::ints_for<T, wi::VAR_PRECISION>::zero (const T &x)
1688 return wi::zero (wi::get_precision (x));
1694 struct int_traits <wi::hwi_with_prec>
1696 static const enum precision_type precision_type = VAR_PRECISION;
1697 /* hwi_with_prec has an explicitly-given precision, rather than the
1698 precision of HOST_WIDE_INT. */
1699 static const bool host_dependent_precision = false;
1700 static const bool is_sign_extended = true;
1701 static unsigned int get_precision (const wi::hwi_with_prec &);
1702 static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int,
1703 const wi::hwi_with_prec &);
1708 wi::int_traits <wi::hwi_with_prec>::get_precision (const wi::hwi_with_prec &x)
1713 inline wi::storage_ref
1714 wi::int_traits <wi::hwi_with_prec>::
1715 decompose (HOST_WIDE_INT *scratch, unsigned int precision,
1716 const wi::hwi_with_prec &x)
1718 gcc_checking_assert (precision == x.precision);
1720 if (x.sgn == SIGNED || x.val >= 0 || precision <= HOST_BITS_PER_WIDE_INT)
1721 return wi::storage_ref (scratch, 1, precision);
1723 return wi::storage_ref (scratch, 2, precision);
1726 /* Private functions for handling large cases out of line. They take
1727 individual length and array parameters because that is cheaper for
1728 the inline caller than constructing an object on the stack and
1729 passing a reference to it. (Although many callers use wide_int_refs,
1730 we generally want those to be removed by SRA.) */
1733 bool eq_p_large (const HOST_WIDE_INT *, unsigned int,
1734 const HOST_WIDE_INT *, unsigned int, unsigned int);
1735 bool lts_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
1736 const HOST_WIDE_INT *, unsigned int);
1737 bool ltu_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
1738 const HOST_WIDE_INT *, unsigned int);
1739 int cmps_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
1740 const HOST_WIDE_INT *, unsigned int);
1741 int cmpu_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
1742 const HOST_WIDE_INT *, unsigned int);
1743 unsigned int sext_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1745 unsigned int, unsigned int);
1746 unsigned int zext_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1748 unsigned int, unsigned int);
1749 unsigned int set_bit_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1750 unsigned int, unsigned int, unsigned int);
1751 unsigned int lshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1752 unsigned int, unsigned int, unsigned int);
1753 unsigned int lrshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1754 unsigned int, unsigned int, unsigned int,
1756 unsigned int arshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1757 unsigned int, unsigned int, unsigned int,
1759 unsigned int and_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
1760 const HOST_WIDE_INT *, unsigned int, unsigned int);
1761 unsigned int and_not_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1762 unsigned int, const HOST_WIDE_INT *,
1763 unsigned int, unsigned int);
1764 unsigned int or_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
1765 const HOST_WIDE_INT *, unsigned int, unsigned int);
1766 unsigned int or_not_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1767 unsigned int, const HOST_WIDE_INT *,
1768 unsigned int, unsigned int);
1769 unsigned int xor_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
1770 const HOST_WIDE_INT *, unsigned int, unsigned int);
1771 unsigned int add_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
1772 const HOST_WIDE_INT *, unsigned int, unsigned int,
1773 signop, overflow_type *);
1774 unsigned int sub_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
1775 const HOST_WIDE_INT *, unsigned int, unsigned int,
1776 signop, overflow_type *);
1777 unsigned int mul_internal (HOST_WIDE_INT *, const HOST_WIDE_INT *,
1778 unsigned int, const HOST_WIDE_INT *,
1779 unsigned int, unsigned int, signop,
1780 overflow_type *, bool);
1781 unsigned int divmod_internal (HOST_WIDE_INT *, unsigned int *,
1782 HOST_WIDE_INT *, const HOST_WIDE_INT *,
1783 unsigned int, unsigned int,
1784 const HOST_WIDE_INT *,
1785 unsigned int, unsigned int,
1786 signop, overflow_type *);
1789 /* Return the number of bits that integer X can hold. */
1790 template <typename T>
1792 wi::get_precision (const T &x)
1794 return wi::int_traits <T>::get_precision (x);
1797 /* Return the number of bits that the result of a binary operation can
1798 hold when the input operands are X and Y. */
1799 template <typename T1, typename T2>
1801 wi::get_binary_precision (const T1 &x, const T2 &y)
1803 return get_precision (wi::int_traits <WI_BINARY_RESULT (T1, T2)>::
1804 get_binary_result (x, y));
1807 /* Copy the contents of Y to X, but keeping X's current precision. */
1808 template <typename T1, typename T2>
1810 wi::copy (T1 &x, const T2 &y)
1812 HOST_WIDE_INT *xval = x.write_val ();
1813 const HOST_WIDE_INT *yval = y.get_val ();
1814 unsigned int len = y.get_len ();
1819 x.set_len (len, y.is_sign_extended);
1822 /* Return true if X fits in a HOST_WIDE_INT with no loss of precision. */
1823 template <typename T>
1825 wi::fits_shwi_p (const T &x)
1827 WIDE_INT_REF_FOR (T) xi (x);
1831 /* Return true if X fits in an unsigned HOST_WIDE_INT with no loss of
1833 template <typename T>
1835 wi::fits_uhwi_p (const T &x)
1837 WIDE_INT_REF_FOR (T) xi (x);
1838 if (xi.precision <= HOST_BITS_PER_WIDE_INT)
1841 return xi.slow () >= 0;
1842 return xi.len == 2 && xi.uhigh () == 0;
1845 /* Return true if X is negative based on the interpretation of SGN.
1846 For UNSIGNED, this is always false. */
1847 template <typename T>
1849 wi::neg_p (const T &x, signop sgn)
1851 WIDE_INT_REF_FOR (T) xi (x);
1852 if (sgn == UNSIGNED)
1854 return xi.sign_mask () < 0;
1857 /* Return -1 if the top bit of X is set and 0 if the top bit is clear. */
1858 template <typename T>
1859 inline HOST_WIDE_INT
1860 wi::sign_mask (const T &x)
1862 WIDE_INT_REF_FOR (T) xi (x);
1863 return xi.sign_mask ();
1866 /* Return true if X == Y. X and Y must be binary-compatible. */
1867 template <typename T1, typename T2>
1869 wi::eq_p (const T1 &x, const T2 &y)
1871 unsigned int precision = get_binary_precision (x, y);
1872 WIDE_INT_REF_FOR (T1) xi (x, precision);
1873 WIDE_INT_REF_FOR (T2) yi (y, precision);
1874 if (xi.is_sign_extended && yi.is_sign_extended)
1876 /* This case reduces to array equality. */
1877 if (xi.len != yi.len)
1881 if (xi.val[i] != yi.val[i])
1883 while (++i != xi.len);
1886 if (LIKELY (yi.len == 1))
1888 /* XI is only equal to YI if it too has a single HWI. */
1891 /* Excess bits in xi.val[0] will be signs or zeros, so comparisons
1892 with 0 are simple. */
1893 if (STATIC_CONSTANT_P (yi.val[0] == 0))
1894 return xi.val[0] == 0;
1895 /* Otherwise flush out any excess bits first. */
1896 unsigned HOST_WIDE_INT diff = xi.val[0] ^ yi.val[0];
1897 int excess = HOST_BITS_PER_WIDE_INT - precision;
1902 return eq_p_large (xi.val, xi.len, yi.val, yi.len, precision);
1905 /* Return true if X != Y. X and Y must be binary-compatible. */
1906 template <typename T1, typename T2>
1908 wi::ne_p (const T1 &x, const T2 &y)
1910 return !eq_p (x, y);
1913 /* Return true if X < Y when both are treated as signed values. */
1914 template <typename T1, typename T2>
1916 wi::lts_p (const T1 &x, const T2 &y)
1918 unsigned int precision = get_binary_precision (x, y);
1919 WIDE_INT_REF_FOR (T1) xi (x, precision);
1920 WIDE_INT_REF_FOR (T2) yi (y, precision);
1921 /* We optimize x < y, where y is 64 or fewer bits. */
1922 if (wi::fits_shwi_p (yi))
1924 /* Make lts_p (x, 0) as efficient as wi::neg_p (x). */
1925 if (STATIC_CONSTANT_P (yi.val[0] == 0))
1927 /* If x fits directly into a shwi, we can compare directly. */
1928 if (wi::fits_shwi_p (xi))
1929 return xi.to_shwi () < yi.to_shwi ();
1930 /* If x doesn't fit and is negative, then it must be more
1931 negative than any value in y, and hence smaller than y. */
1934 /* If x is positive, then it must be larger than any value in y,
1935 and hence greater than y. */
1938 /* Optimize the opposite case, if it can be detected at compile time. */
1939 if (STATIC_CONSTANT_P (xi.len == 1))
1940 /* If YI is negative it is lower than the least HWI.
1941 If YI is positive it is greater than the greatest HWI. */
1943 return lts_p_large (xi.val, xi.len, precision, yi.val, yi.len);
1946 /* Return true if X < Y when both are treated as unsigned values. */
1947 template <typename T1, typename T2>
1949 wi::ltu_p (const T1 &x, const T2 &y)
1951 unsigned int precision = get_binary_precision (x, y);
1952 WIDE_INT_REF_FOR (T1) xi (x, precision);
1953 WIDE_INT_REF_FOR (T2) yi (y, precision);
1954 /* Optimize comparisons with constants. */
1955 if (STATIC_CONSTANT_P (yi.len == 1 && yi.val[0] >= 0))
1956 return xi.len == 1 && xi.to_uhwi () < (unsigned HOST_WIDE_INT) yi.val[0];
1957 if (STATIC_CONSTANT_P (xi.len == 1 && xi.val[0] >= 0))
1958 return yi.len != 1 || yi.to_uhwi () > (unsigned HOST_WIDE_INT) xi.val[0];
1959 /* Optimize the case of two HWIs. The HWIs are implicitly sign-extended
1960 for precisions greater than HOST_BITS_WIDE_INT, but sign-extending both
1961 values does not change the result. */
1962 if (LIKELY (xi.len + yi.len == 2))
1964 unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
1965 unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
1968 return ltu_p_large (xi.val, xi.len, precision, yi.val, yi.len);
1971 /* Return true if X < Y. Signedness of X and Y is indicated by SGN. */
1972 template <typename T1, typename T2>
1974 wi::lt_p (const T1 &x, const T2 &y, signop sgn)
1977 return lts_p (x, y);
1979 return ltu_p (x, y);
1982 /* Return true if X <= Y when both are treated as signed values. */
1983 template <typename T1, typename T2>
1985 wi::les_p (const T1 &x, const T2 &y)
1987 return !lts_p (y, x);
1990 /* Return true if X <= Y when both are treated as unsigned values. */
1991 template <typename T1, typename T2>
1993 wi::leu_p (const T1 &x, const T2 &y)
1995 return !ltu_p (y, x);
1998 /* Return true if X <= Y. Signedness of X and Y is indicated by SGN. */
1999 template <typename T1, typename T2>
2001 wi::le_p (const T1 &x, const T2 &y, signop sgn)
2004 return les_p (x, y);
2006 return leu_p (x, y);
2009 /* Return true if X > Y when both are treated as signed values. */
2010 template <typename T1, typename T2>
2012 wi::gts_p (const T1 &x, const T2 &y)
2014 return lts_p (y, x);
2017 /* Return true if X > Y when both are treated as unsigned values. */
2018 template <typename T1, typename T2>
2020 wi::gtu_p (const T1 &x, const T2 &y)
2022 return ltu_p (y, x);
2025 /* Return true if X > Y. Signedness of X and Y is indicated by SGN. */
2026 template <typename T1, typename T2>
2028 wi::gt_p (const T1 &x, const T2 &y, signop sgn)
2031 return gts_p (x, y);
2033 return gtu_p (x, y);
2036 /* Return true if X >= Y when both are treated as signed values. */
2037 template <typename T1, typename T2>
2039 wi::ges_p (const T1 &x, const T2 &y)
2041 return !lts_p (x, y);
2044 /* Return true if X >= Y when both are treated as unsigned values. */
2045 template <typename T1, typename T2>
2047 wi::geu_p (const T1 &x, const T2 &y)
2049 return !ltu_p (x, y);
2052 /* Return true if X >= Y. Signedness of X and Y is indicated by SGN. */
2053 template <typename T1, typename T2>
2055 wi::ge_p (const T1 &x, const T2 &y, signop sgn)
2058 return ges_p (x, y);
2060 return geu_p (x, y);
2063 /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y. Treat both X and Y
2064 as signed values. */
2065 template <typename T1, typename T2>
2067 wi::cmps (const T1 &x, const T2 &y)
2069 unsigned int precision = get_binary_precision (x, y);
2070 WIDE_INT_REF_FOR (T1) xi (x, precision);
2071 WIDE_INT_REF_FOR (T2) yi (y, precision);
2072 if (wi::fits_shwi_p (yi))
2074 /* Special case for comparisons with 0. */
2075 if (STATIC_CONSTANT_P (yi.val[0] == 0))
2076 return neg_p (xi) ? -1 : !(xi.len == 1 && xi.val[0] == 0);
2077 /* If x fits into a signed HWI, we can compare directly. */
2078 if (wi::fits_shwi_p (xi))
2080 HOST_WIDE_INT xl = xi.to_shwi ();
2081 HOST_WIDE_INT yl = yi.to_shwi ();
2082 return xl < yl ? -1 : xl > yl;
2084 /* If x doesn't fit and is negative, then it must be more
2085 negative than any signed HWI, and hence smaller than y. */
2088 /* If x is positive, then it must be larger than any signed HWI,
2089 and hence greater than y. */
2092 /* Optimize the opposite case, if it can be detected at compile time. */
2093 if (STATIC_CONSTANT_P (xi.len == 1))
2094 /* If YI is negative it is lower than the least HWI.
2095 If YI is positive it is greater than the greatest HWI. */
2096 return neg_p (yi) ? 1 : -1;
2097 return cmps_large (xi.val, xi.len, precision, yi.val, yi.len);
2100 /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y. Treat both X and Y
2101 as unsigned values. */
2102 template <typename T1, typename T2>
2104 wi::cmpu (const T1 &x, const T2 &y)
2106 unsigned int precision = get_binary_precision (x, y);
2107 WIDE_INT_REF_FOR (T1) xi (x, precision);
2108 WIDE_INT_REF_FOR (T2) yi (y, precision);
2109 /* Optimize comparisons with constants. */
2110 if (STATIC_CONSTANT_P (yi.len == 1 && yi.val[0] >= 0))
2112 /* If XI doesn't fit in a HWI then it must be larger than YI. */
2115 /* Otherwise compare directly. */
2116 unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
2117 unsigned HOST_WIDE_INT yl = yi.val[0];
2118 return xl < yl ? -1 : xl > yl;
2120 if (STATIC_CONSTANT_P (xi.len == 1 && xi.val[0] >= 0))
2122 /* If YI doesn't fit in a HWI then it must be larger than XI. */
2125 /* Otherwise compare directly. */
2126 unsigned HOST_WIDE_INT xl = xi.val[0];
2127 unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
2128 return xl < yl ? -1 : xl > yl;
2130 /* Optimize the case of two HWIs. The HWIs are implicitly sign-extended
2131 for precisions greater than HOST_BITS_WIDE_INT, but sign-extending both
2132 values does not change the result. */
2133 if (LIKELY (xi.len + yi.len == 2))
2135 unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
2136 unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
2137 return xl < yl ? -1 : xl > yl;
2139 return cmpu_large (xi.val, xi.len, precision, yi.val, yi.len);
2142 /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y. Signedness of
2143 X and Y indicated by SGN. */
2144 template <typename T1, typename T2>
2146 wi::cmp (const T1 &x, const T2 &y, signop sgn)
2155 template <typename T>
2156 inline WI_UNARY_RESULT (T)
2157 wi::bit_not (const T &x)
2159 WI_UNARY_RESULT_VAR (result, val, T, x);
2160 WIDE_INT_REF_FOR (T) xi (x, get_precision (result));
2161 for (unsigned int i = 0; i < xi.len; ++i)
2162 val[i] = ~xi.val[i];
2163 result.set_len (xi.len);
2168 template <typename T>
2169 inline WI_UNARY_RESULT (T)
2170 wi::neg (const T &x)
2175 /* Return -x. Indicate in *OVERFLOW if performing the negation would
2176 cause an overflow. */
2177 template <typename T>
2178 inline WI_UNARY_RESULT (T)
2179 wi::neg (const T &x, overflow_type *overflow)
2181 *overflow = only_sign_bit_p (x) ? OVF_OVERFLOW : OVF_NONE;
2185 /* Return the absolute value of x. */
2186 template <typename T>
2187 inline WI_UNARY_RESULT (T)
2188 wi::abs (const T &x)
2190 return neg_p (x) ? neg (x) : WI_UNARY_RESULT (T) (x);
2193 /* Return the result of sign-extending the low OFFSET bits of X. */
2194 template <typename T>
2195 inline WI_UNARY_RESULT (T)
2196 wi::sext (const T &x, unsigned int offset)
2198 WI_UNARY_RESULT_VAR (result, val, T, x);
2199 unsigned int precision = get_precision (result);
2200 WIDE_INT_REF_FOR (T) xi (x, precision);
2202 if (offset <= HOST_BITS_PER_WIDE_INT)
2204 val[0] = sext_hwi (xi.ulow (), offset);
2205 result.set_len (1, true);
2208 result.set_len (sext_large (val, xi.val, xi.len, precision, offset));
2212 /* Return the result of zero-extending the low OFFSET bits of X. */
2213 template <typename T>
2214 inline WI_UNARY_RESULT (T)
2215 wi::zext (const T &x, unsigned int offset)
2217 WI_UNARY_RESULT_VAR (result, val, T, x);
2218 unsigned int precision = get_precision (result);
2219 WIDE_INT_REF_FOR (T) xi (x, precision);
2221 /* This is not just an optimization, it is actually required to
2222 maintain canonization. */
2223 if (offset >= precision)
2225 wi::copy (result, xi);
2229 /* In these cases we know that at least the top bit will be clear,
2230 so no sign extension is necessary. */
2231 if (offset < HOST_BITS_PER_WIDE_INT)
2233 val[0] = zext_hwi (xi.ulow (), offset);
2234 result.set_len (1, true);
2237 result.set_len (zext_large (val, xi.val, xi.len, precision, offset), true);
2241 /* Return the result of extending the low OFFSET bits of X according to
2243 template <typename T>
2244 inline WI_UNARY_RESULT (T)
2245 wi::ext (const T &x, unsigned int offset, signop sgn)
2247 return sgn == SIGNED ? sext (x, offset) : zext (x, offset);
2250 /* Return an integer that represents X | (1 << bit). */
2251 template <typename T>
2252 inline WI_UNARY_RESULT (T)
2253 wi::set_bit (const T &x, unsigned int bit)
2255 WI_UNARY_RESULT_VAR (result, val, T, x);
2256 unsigned int precision = get_precision (result);
2257 WIDE_INT_REF_FOR (T) xi (x, precision);
2258 if (precision <= HOST_BITS_PER_WIDE_INT)
2260 val[0] = xi.ulow () | (HOST_WIDE_INT_1U << bit);
2264 result.set_len (set_bit_large (val, xi.val, xi.len, precision, bit));
2268 /* Return the mininum of X and Y, treating them both as having
2270 template <typename T1, typename T2>
2271 inline WI_BINARY_RESULT (T1, T2)
2272 wi::min (const T1 &x, const T2 &y, signop sgn)
2274 WI_BINARY_RESULT_VAR (result, val ATTRIBUTE_UNUSED, T1, x, T2, y);
2275 unsigned int precision = get_precision (result);
2276 if (wi::le_p (x, y, sgn))
2277 wi::copy (result, WIDE_INT_REF_FOR (T1) (x, precision));
2279 wi::copy (result, WIDE_INT_REF_FOR (T2) (y, precision));
2283 /* Return the minimum of X and Y, treating both as signed values. */
2284 template <typename T1, typename T2>
2285 inline WI_BINARY_RESULT (T1, T2)
2286 wi::smin (const T1 &x, const T2 &y)
2288 return wi::min (x, y, SIGNED);
2291 /* Return the minimum of X and Y, treating both as unsigned values. */
2292 template <typename T1, typename T2>
2293 inline WI_BINARY_RESULT (T1, T2)
2294 wi::umin (const T1 &x, const T2 &y)
2296 return wi::min (x, y, UNSIGNED);
2299 /* Return the maxinum of X and Y, treating them both as having
2301 template <typename T1, typename T2>
2302 inline WI_BINARY_RESULT (T1, T2)
2303 wi::max (const T1 &x, const T2 &y, signop sgn)
2305 WI_BINARY_RESULT_VAR (result, val ATTRIBUTE_UNUSED, T1, x, T2, y);
2306 unsigned int precision = get_precision (result);
2307 if (wi::ge_p (x, y, sgn))
2308 wi::copy (result, WIDE_INT_REF_FOR (T1) (x, precision));
2310 wi::copy (result, WIDE_INT_REF_FOR (T2) (y, precision));
2314 /* Return the maximum of X and Y, treating both as signed values. */
2315 template <typename T1, typename T2>
2316 inline WI_BINARY_RESULT (T1, T2)
2317 wi::smax (const T1 &x, const T2 &y)
2319 return wi::max (x, y, SIGNED);
2322 /* Return the maximum of X and Y, treating both as unsigned values. */
2323 template <typename T1, typename T2>
2324 inline WI_BINARY_RESULT (T1, T2)
2325 wi::umax (const T1 &x, const T2 &y)
2327 return wi::max (x, y, UNSIGNED);
2331 template <typename T1, typename T2>
2332 inline WI_BINARY_RESULT (T1, T2)
2333 wi::bit_and (const T1 &x, const T2 &y)
2335 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2336 unsigned int precision = get_precision (result);
2337 WIDE_INT_REF_FOR (T1) xi (x, precision);
2338 WIDE_INT_REF_FOR (T2) yi (y, precision);
2339 bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
2340 if (LIKELY (xi.len + yi.len == 2))
2342 val[0] = xi.ulow () & yi.ulow ();
2343 result.set_len (1, is_sign_extended);
2346 result.set_len (and_large (val, xi.val, xi.len, yi.val, yi.len,
2347 precision), is_sign_extended);
2351 /* Return X & ~Y. */
2352 template <typename T1, typename T2>
2353 inline WI_BINARY_RESULT (T1, T2)
2354 wi::bit_and_not (const T1 &x, const T2 &y)
2356 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2357 unsigned int precision = get_precision (result);
2358 WIDE_INT_REF_FOR (T1) xi (x, precision);
2359 WIDE_INT_REF_FOR (T2) yi (y, precision);
2360 bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
2361 if (LIKELY (xi.len + yi.len == 2))
2363 val[0] = xi.ulow () & ~yi.ulow ();
2364 result.set_len (1, is_sign_extended);
2367 result.set_len (and_not_large (val, xi.val, xi.len, yi.val, yi.len,
2368 precision), is_sign_extended);
2373 template <typename T1, typename T2>
2374 inline WI_BINARY_RESULT (T1, T2)
2375 wi::bit_or (const T1 &x, const T2 &y)
2377 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2378 unsigned int precision = get_precision (result);
2379 WIDE_INT_REF_FOR (T1) xi (x, precision);
2380 WIDE_INT_REF_FOR (T2) yi (y, precision);
2381 bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
2382 if (LIKELY (xi.len + yi.len == 2))
2384 val[0] = xi.ulow () | yi.ulow ();
2385 result.set_len (1, is_sign_extended);
2388 result.set_len (or_large (val, xi.val, xi.len,
2389 yi.val, yi.len, precision), is_sign_extended);
2393 /* Return X | ~Y. */
2394 template <typename T1, typename T2>
2395 inline WI_BINARY_RESULT (T1, T2)
2396 wi::bit_or_not (const T1 &x, const T2 &y)
2398 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2399 unsigned int precision = get_precision (result);
2400 WIDE_INT_REF_FOR (T1) xi (x, precision);
2401 WIDE_INT_REF_FOR (T2) yi (y, precision);
2402 bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
2403 if (LIKELY (xi.len + yi.len == 2))
2405 val[0] = xi.ulow () | ~yi.ulow ();
2406 result.set_len (1, is_sign_extended);
2409 result.set_len (or_not_large (val, xi.val, xi.len, yi.val, yi.len,
2410 precision), is_sign_extended);
2415 template <typename T1, typename T2>
2416 inline WI_BINARY_RESULT (T1, T2)
2417 wi::bit_xor (const T1 &x, const T2 &y)
2419 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2420 unsigned int precision = get_precision (result);
2421 WIDE_INT_REF_FOR (T1) xi (x, precision);
2422 WIDE_INT_REF_FOR (T2) yi (y, precision);
2423 bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
2424 if (LIKELY (xi.len + yi.len == 2))
2426 val[0] = xi.ulow () ^ yi.ulow ();
2427 result.set_len (1, is_sign_extended);
2430 result.set_len (xor_large (val, xi.val, xi.len,
2431 yi.val, yi.len, precision), is_sign_extended);
2436 template <typename T1, typename T2>
2437 inline WI_BINARY_RESULT (T1, T2)
2438 wi::add (const T1 &x, const T2 &y)
2440 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2441 unsigned int precision = get_precision (result);
2442 WIDE_INT_REF_FOR (T1) xi (x, precision);
2443 WIDE_INT_REF_FOR (T2) yi (y, precision);
2444 if (precision <= HOST_BITS_PER_WIDE_INT)
2446 val[0] = xi.ulow () + yi.ulow ();
2449 /* If the precision is known at compile time to be greater than
2450 HOST_BITS_PER_WIDE_INT, we can optimize the single-HWI case
2451 knowing that (a) all bits in those HWIs are significant and
2452 (b) the result has room for at least two HWIs. This provides
2453 a fast path for things like offset_int and widest_int.
2455 The STATIC_CONSTANT_P test prevents this path from being
2456 used for wide_ints. wide_ints with precisions greater than
2457 HOST_BITS_PER_WIDE_INT are relatively rare and there's not much
2458 point handling them inline. */
2459 else if (STATIC_CONSTANT_P (precision > HOST_BITS_PER_WIDE_INT)
2460 && LIKELY (xi.len + yi.len == 2))
2462 unsigned HOST_WIDE_INT xl = xi.ulow ();
2463 unsigned HOST_WIDE_INT yl = yi.ulow ();
2464 unsigned HOST_WIDE_INT resultl = xl + yl;
2466 val[1] = (HOST_WIDE_INT) resultl < 0 ? 0 : -1;
2467 result.set_len (1 + (((resultl ^ xl) & (resultl ^ yl))
2468 >> (HOST_BITS_PER_WIDE_INT - 1)));
2471 result.set_len (add_large (val, xi.val, xi.len,
2472 yi.val, yi.len, precision,
2477 /* Return X + Y. Treat X and Y as having the signednes given by SGN
2478 and indicate in *OVERFLOW whether the operation overflowed. */
2479 template <typename T1, typename T2>
2480 inline WI_BINARY_RESULT (T1, T2)
2481 wi::add (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2483 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2484 unsigned int precision = get_precision (result);
2485 WIDE_INT_REF_FOR (T1) xi (x, precision);
2486 WIDE_INT_REF_FOR (T2) yi (y, precision);
2487 if (precision <= HOST_BITS_PER_WIDE_INT)
2489 unsigned HOST_WIDE_INT xl = xi.ulow ();
2490 unsigned HOST_WIDE_INT yl = yi.ulow ();
2491 unsigned HOST_WIDE_INT resultl = xl + yl;
2494 if ((((resultl ^ xl) & (resultl ^ yl))
2495 >> (precision - 1)) & 1)
2498 *overflow = OVF_UNDERFLOW;
2499 else if (xl < resultl)
2500 *overflow = OVF_OVERFLOW;
2502 *overflow = OVF_NONE;
2505 *overflow = OVF_NONE;
2508 *overflow = ((resultl << (HOST_BITS_PER_WIDE_INT - precision))
2509 < (xl << (HOST_BITS_PER_WIDE_INT - precision)))
2510 ? OVF_OVERFLOW : OVF_NONE;
2515 result.set_len (add_large (val, xi.val, xi.len,
2516 yi.val, yi.len, precision,
2522 template <typename T1, typename T2>
2523 inline WI_BINARY_RESULT (T1, T2)
2524 wi::sub (const T1 &x, const T2 &y)
2526 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2527 unsigned int precision = get_precision (result);
2528 WIDE_INT_REF_FOR (T1) xi (x, precision);
2529 WIDE_INT_REF_FOR (T2) yi (y, precision);
2530 if (precision <= HOST_BITS_PER_WIDE_INT)
2532 val[0] = xi.ulow () - yi.ulow ();
2535 /* If the precision is known at compile time to be greater than
2536 HOST_BITS_PER_WIDE_INT, we can optimize the single-HWI case
2537 knowing that (a) all bits in those HWIs are significant and
2538 (b) the result has room for at least two HWIs. This provides
2539 a fast path for things like offset_int and widest_int.
2541 The STATIC_CONSTANT_P test prevents this path from being
2542 used for wide_ints. wide_ints with precisions greater than
2543 HOST_BITS_PER_WIDE_INT are relatively rare and there's not much
2544 point handling them inline. */
2545 else if (STATIC_CONSTANT_P (precision > HOST_BITS_PER_WIDE_INT)
2546 && LIKELY (xi.len + yi.len == 2))
2548 unsigned HOST_WIDE_INT xl = xi.ulow ();
2549 unsigned HOST_WIDE_INT yl = yi.ulow ();
2550 unsigned HOST_WIDE_INT resultl = xl - yl;
2552 val[1] = (HOST_WIDE_INT) resultl < 0 ? 0 : -1;
2553 result.set_len (1 + (((resultl ^ xl) & (xl ^ yl))
2554 >> (HOST_BITS_PER_WIDE_INT - 1)));
2557 result.set_len (sub_large (val, xi.val, xi.len,
2558 yi.val, yi.len, precision,
2563 /* Return X - Y. Treat X and Y as having the signednes given by SGN
2564 and indicate in *OVERFLOW whether the operation overflowed. */
2565 template <typename T1, typename T2>
2566 inline WI_BINARY_RESULT (T1, T2)
2567 wi::sub (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2569 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2570 unsigned int precision = get_precision (result);
2571 WIDE_INT_REF_FOR (T1) xi (x, precision);
2572 WIDE_INT_REF_FOR (T2) yi (y, precision);
2573 if (precision <= HOST_BITS_PER_WIDE_INT)
2575 unsigned HOST_WIDE_INT xl = xi.ulow ();
2576 unsigned HOST_WIDE_INT yl = yi.ulow ();
2577 unsigned HOST_WIDE_INT resultl = xl - yl;
2580 if ((((xl ^ yl) & (resultl ^ xl)) >> (precision - 1)) & 1)
2583 *overflow = OVF_UNDERFLOW;
2585 *overflow = OVF_OVERFLOW;
2587 *overflow = OVF_NONE;
2590 *overflow = OVF_NONE;
2593 *overflow = ((resultl << (HOST_BITS_PER_WIDE_INT - precision))
2594 > (xl << (HOST_BITS_PER_WIDE_INT - precision)))
2595 ? OVF_UNDERFLOW : OVF_NONE;
2600 result.set_len (sub_large (val, xi.val, xi.len,
2601 yi.val, yi.len, precision,
2607 template <typename T1, typename T2>
2608 inline WI_BINARY_RESULT (T1, T2)
2609 wi::mul (const T1 &x, const T2 &y)
2611 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2612 unsigned int precision = get_precision (result);
2613 WIDE_INT_REF_FOR (T1) xi (x, precision);
2614 WIDE_INT_REF_FOR (T2) yi (y, precision);
2615 if (precision <= HOST_BITS_PER_WIDE_INT)
2617 val[0] = xi.ulow () * yi.ulow ();
2621 result.set_len (mul_internal (val, xi.val, xi.len, yi.val, yi.len,
2622 precision, UNSIGNED, 0, false));
2626 /* Return X * Y. Treat X and Y as having the signednes given by SGN
2627 and indicate in *OVERFLOW whether the operation overflowed. */
2628 template <typename T1, typename T2>
2629 inline WI_BINARY_RESULT (T1, T2)
2630 wi::mul (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2632 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2633 unsigned int precision = get_precision (result);
2634 WIDE_INT_REF_FOR (T1) xi (x, precision);
2635 WIDE_INT_REF_FOR (T2) yi (y, precision);
2636 result.set_len (mul_internal (val, xi.val, xi.len,
2637 yi.val, yi.len, precision,
2638 sgn, overflow, false));
2642 /* Return X * Y, treating both X and Y as signed values. Indicate in
2643 *OVERFLOW whether the operation overflowed. */
2644 template <typename T1, typename T2>
2645 inline WI_BINARY_RESULT (T1, T2)
2646 wi::smul (const T1 &x, const T2 &y, overflow_type *overflow)
2648 return mul (x, y, SIGNED, overflow);
2651 /* Return X * Y, treating both X and Y as unsigned values. Indicate in
2652 *OVERFLOW if the result overflows. */
2653 template <typename T1, typename T2>
2654 inline WI_BINARY_RESULT (T1, T2)
2655 wi::umul (const T1 &x, const T2 &y, overflow_type *overflow)
2657 return mul (x, y, UNSIGNED, overflow);
2660 /* Perform a widening multiplication of X and Y, extending the values
2661 according to SGN, and return the high part of the result. */
2662 template <typename T1, typename T2>
2663 inline WI_BINARY_RESULT (T1, T2)
2664 wi::mul_high (const T1 &x, const T2 &y, signop sgn)
2666 WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
2667 unsigned int precision = get_precision (result);
2668 WIDE_INT_REF_FOR (T1) xi (x, precision);
2669 WIDE_INT_REF_FOR (T2) yi (y, precision);
2670 result.set_len (mul_internal (val, xi.val, xi.len,
2671 yi.val, yi.len, precision,
2676 /* Return X / Y, rouding towards 0. Treat X and Y as having the
2677 signedness given by SGN. Indicate in *OVERFLOW if the result
2679 template <typename T1, typename T2>
2680 inline WI_BINARY_RESULT (T1, T2)
2681 wi::div_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2683 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2684 unsigned int precision = get_precision (quotient);
2685 WIDE_INT_REF_FOR (T1) xi (x, precision);
2686 WIDE_INT_REF_FOR (T2) yi (y);
2688 quotient.set_len (divmod_internal (quotient_val, 0, 0, xi.val, xi.len,
2690 yi.val, yi.len, yi.precision,
2695 /* Return X / Y, rouding towards 0. Treat X and Y as signed values. */
2696 template <typename T1, typename T2>
2697 inline WI_BINARY_RESULT (T1, T2)
2698 wi::sdiv_trunc (const T1 &x, const T2 &y)
2700 return div_trunc (x, y, SIGNED);
2703 /* Return X / Y, rouding towards 0. Treat X and Y as unsigned values. */
2704 template <typename T1, typename T2>
2705 inline WI_BINARY_RESULT (T1, T2)
2706 wi::udiv_trunc (const T1 &x, const T2 &y)
2708 return div_trunc (x, y, UNSIGNED);
2711 /* Return X / Y, rouding towards -inf. Treat X and Y as having the
2712 signedness given by SGN. Indicate in *OVERFLOW if the result
2714 template <typename T1, typename T2>
2715 inline WI_BINARY_RESULT (T1, T2)
2716 wi::div_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2718 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2719 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2720 unsigned int precision = get_precision (quotient);
2721 WIDE_INT_REF_FOR (T1) xi (x, precision);
2722 WIDE_INT_REF_FOR (T2) yi (y);
2724 unsigned int remainder_len;
2725 quotient.set_len (divmod_internal (quotient_val,
2726 &remainder_len, remainder_val,
2727 xi.val, xi.len, precision,
2728 yi.val, yi.len, yi.precision, sgn,
2730 remainder.set_len (remainder_len);
2731 if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
2732 return quotient - 1;
2736 /* Return X / Y, rouding towards -inf. Treat X and Y as signed values. */
2737 template <typename T1, typename T2>
2738 inline WI_BINARY_RESULT (T1, T2)
2739 wi::sdiv_floor (const T1 &x, const T2 &y)
2741 return div_floor (x, y, SIGNED);
2744 /* Return X / Y, rouding towards -inf. Treat X and Y as unsigned values. */
2745 /* ??? Why do we have both this and udiv_trunc. Aren't they the same? */
2746 template <typename T1, typename T2>
2747 inline WI_BINARY_RESULT (T1, T2)
2748 wi::udiv_floor (const T1 &x, const T2 &y)
2750 return div_floor (x, y, UNSIGNED);
2753 /* Return X / Y, rouding towards +inf. Treat X and Y as having the
2754 signedness given by SGN. Indicate in *OVERFLOW if the result
2756 template <typename T1, typename T2>
2757 inline WI_BINARY_RESULT (T1, T2)
2758 wi::div_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2760 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2761 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2762 unsigned int precision = get_precision (quotient);
2763 WIDE_INT_REF_FOR (T1) xi (x, precision);
2764 WIDE_INT_REF_FOR (T2) yi (y);
2766 unsigned int remainder_len;
2767 quotient.set_len (divmod_internal (quotient_val,
2768 &remainder_len, remainder_val,
2769 xi.val, xi.len, precision,
2770 yi.val, yi.len, yi.precision, sgn,
2772 remainder.set_len (remainder_len);
2773 if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
2774 return quotient + 1;
2778 /* Return X / Y, rouding towards +inf. Treat X and Y as unsigned values. */
2779 template <typename T1, typename T2>
2780 inline WI_BINARY_RESULT (T1, T2)
2781 wi::udiv_ceil (const T1 &x, const T2 &y)
2783 return div_ceil (x, y, UNSIGNED);
2786 /* Return X / Y, rouding towards nearest with ties away from zero.
2787 Treat X and Y as having the signedness given by SGN. Indicate
2788 in *OVERFLOW if the result overflows. */
2789 template <typename T1, typename T2>
2790 inline WI_BINARY_RESULT (T1, T2)
2791 wi::div_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2793 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2794 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2795 unsigned int precision = get_precision (quotient);
2796 WIDE_INT_REF_FOR (T1) xi (x, precision);
2797 WIDE_INT_REF_FOR (T2) yi (y);
2799 unsigned int remainder_len;
2800 quotient.set_len (divmod_internal (quotient_val,
2801 &remainder_len, remainder_val,
2802 xi.val, xi.len, precision,
2803 yi.val, yi.len, yi.precision, sgn,
2805 remainder.set_len (remainder_len);
2811 WI_BINARY_RESULT (T1, T2) abs_remainder = wi::abs (remainder);
2812 if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
2814 if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
2815 return quotient - 1;
2817 return quotient + 1;
2822 if (wi::geu_p (remainder, wi::sub (y, remainder)))
2823 return quotient + 1;
2829 /* Return X / Y, rouding towards 0. Treat X and Y as having the
2830 signedness given by SGN. Store the remainder in *REMAINDER_PTR. */
2831 template <typename T1, typename T2>
2832 inline WI_BINARY_RESULT (T1, T2)
2833 wi::divmod_trunc (const T1 &x, const T2 &y, signop sgn,
2834 WI_BINARY_RESULT (T1, T2) *remainder_ptr)
2836 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2837 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2838 unsigned int precision = get_precision (quotient);
2839 WIDE_INT_REF_FOR (T1) xi (x, precision);
2840 WIDE_INT_REF_FOR (T2) yi (y);
2842 unsigned int remainder_len;
2843 quotient.set_len (divmod_internal (quotient_val,
2844 &remainder_len, remainder_val,
2845 xi.val, xi.len, precision,
2846 yi.val, yi.len, yi.precision, sgn, 0));
2847 remainder.set_len (remainder_len);
2849 *remainder_ptr = remainder;
2853 /* Compute the greatest common divisor of two numbers A and B using
2854 Euclid's algorithm. */
2855 template <typename T1, typename T2>
2856 inline WI_BINARY_RESULT (T1, T2)
2857 wi::gcd (const T1 &a, const T2 &b, signop sgn)
2864 while (gt_p (x, 0, sgn))
2866 z = mod_trunc (y, x, sgn);
2874 /* Compute X / Y, rouding towards 0, and return the remainder.
2875 Treat X and Y as having the signedness given by SGN. Indicate
2876 in *OVERFLOW if the division overflows. */
2877 template <typename T1, typename T2>
2878 inline WI_BINARY_RESULT (T1, T2)
2879 wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2881 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2882 unsigned int precision = get_precision (remainder);
2883 WIDE_INT_REF_FOR (T1) xi (x, precision);
2884 WIDE_INT_REF_FOR (T2) yi (y);
2886 unsigned int remainder_len;
2887 divmod_internal (0, &remainder_len, remainder_val,
2888 xi.val, xi.len, precision,
2889 yi.val, yi.len, yi.precision, sgn, overflow);
2890 remainder.set_len (remainder_len);
2895 /* Compute X / Y, rouding towards 0, and return the remainder.
2896 Treat X and Y as signed values. */
2897 template <typename T1, typename T2>
2898 inline WI_BINARY_RESULT (T1, T2)
2899 wi::smod_trunc (const T1 &x, const T2 &y)
2901 return mod_trunc (x, y, SIGNED);
2904 /* Compute X / Y, rouding towards 0, and return the remainder.
2905 Treat X and Y as unsigned values. */
2906 template <typename T1, typename T2>
2907 inline WI_BINARY_RESULT (T1, T2)
2908 wi::umod_trunc (const T1 &x, const T2 &y)
2910 return mod_trunc (x, y, UNSIGNED);
2913 /* Compute X / Y, rouding towards -inf, and return the remainder.
2914 Treat X and Y as having the signedness given by SGN. Indicate
2915 in *OVERFLOW if the division overflows. */
2916 template <typename T1, typename T2>
2917 inline WI_BINARY_RESULT (T1, T2)
2918 wi::mod_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2920 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2921 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2922 unsigned int precision = get_precision (quotient);
2923 WIDE_INT_REF_FOR (T1) xi (x, precision);
2924 WIDE_INT_REF_FOR (T2) yi (y);
2926 unsigned int remainder_len;
2927 quotient.set_len (divmod_internal (quotient_val,
2928 &remainder_len, remainder_val,
2929 xi.val, xi.len, precision,
2930 yi.val, yi.len, yi.precision, sgn,
2932 remainder.set_len (remainder_len);
2934 if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
2935 return remainder + y;
2939 /* Compute X / Y, rouding towards -inf, and return the remainder.
2940 Treat X and Y as unsigned values. */
2941 /* ??? Why do we have both this and umod_trunc. Aren't they the same? */
2942 template <typename T1, typename T2>
2943 inline WI_BINARY_RESULT (T1, T2)
2944 wi::umod_floor (const T1 &x, const T2 &y)
2946 return mod_floor (x, y, UNSIGNED);
2949 /* Compute X / Y, rouding towards +inf, and return the remainder.
2950 Treat X and Y as having the signedness given by SGN. Indicate
2951 in *OVERFLOW if the division overflows. */
2952 template <typename T1, typename T2>
2953 inline WI_BINARY_RESULT (T1, T2)
2954 wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2956 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2957 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2958 unsigned int precision = get_precision (quotient);
2959 WIDE_INT_REF_FOR (T1) xi (x, precision);
2960 WIDE_INT_REF_FOR (T2) yi (y);
2962 unsigned int remainder_len;
2963 quotient.set_len (divmod_internal (quotient_val,
2964 &remainder_len, remainder_val,
2965 xi.val, xi.len, precision,
2966 yi.val, yi.len, yi.precision, sgn,
2968 remainder.set_len (remainder_len);
2970 if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
2971 return remainder - y;
2975 /* Compute X / Y, rouding towards nearest with ties away from zero,
2976 and return the remainder. Treat X and Y as having the signedness
2977 given by SGN. Indicate in *OVERFLOW if the division overflows. */
2978 template <typename T1, typename T2>
2979 inline WI_BINARY_RESULT (T1, T2)
2980 wi::mod_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
2982 WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
2983 WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
2984 unsigned int precision = get_precision (quotient);
2985 WIDE_INT_REF_FOR (T1) xi (x, precision);
2986 WIDE_INT_REF_FOR (T2) yi (y);
2988 unsigned int remainder_len;
2989 quotient.set_len (divmod_internal (quotient_val,
2990 &remainder_len, remainder_val,
2991 xi.val, xi.len, precision,
2992 yi.val, yi.len, yi.precision, sgn,
2994 remainder.set_len (remainder_len);
3000 WI_BINARY_RESULT (T1, T2) abs_remainder = wi::abs (remainder);
3001 if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
3003 if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
3004 return remainder + y;
3006 return remainder - y;
3011 if (wi::geu_p (remainder, wi::sub (y, remainder)))
3012 return remainder - y;
3018 /* Return true if X is a multiple of Y. Treat X and Y as having the
3019 signedness given by SGN. */
3020 template <typename T1, typename T2>
3022 wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn)
3024 return wi::mod_trunc (x, y, sgn) == 0;
3027 /* Return true if X is a multiple of Y, storing X / Y in *RES if so.
3028 Treat X and Y as having the signedness given by SGN. */
3029 template <typename T1, typename T2>
3031 wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn,
3032 WI_BINARY_RESULT (T1, T2) *res)
3034 WI_BINARY_RESULT (T1, T2) remainder;
3035 WI_BINARY_RESULT (T1, T2) quotient
3036 = divmod_trunc (x, y, sgn, &remainder);
3045 /* Return X << Y. Return 0 if Y is greater than or equal to
3046 the precision of X. */
3047 template <typename T1, typename T2>
3048 inline WI_UNARY_RESULT (T1)
3049 wi::lshift (const T1 &x, const T2 &y)
3051 WI_UNARY_RESULT_VAR (result, val, T1, x);
3052 unsigned int precision = get_precision (result);
3053 WIDE_INT_REF_FOR (T1) xi (x, precision);
3054 WIDE_INT_REF_FOR (T2) yi (y);
3055 /* Handle the simple cases quickly. */
3056 if (geu_p (yi, precision))
3063 unsigned int shift = yi.to_uhwi ();
3064 /* For fixed-precision integers like offset_int and widest_int,
3065 handle the case where the shift value is constant and the
3066 result is a single nonnegative HWI (meaning that we don't
3067 need to worry about val[1]). This is particularly common
3068 for converting a byte count to a bit count.
3070 For variable-precision integers like wide_int, handle HWI
3071 and sub-HWI integers inline. */
3072 if (STATIC_CONSTANT_P (xi.precision > HOST_BITS_PER_WIDE_INT)
3073 ? (STATIC_CONSTANT_P (shift < HOST_BITS_PER_WIDE_INT - 1)
3075 && IN_RANGE (xi.val[0], 0, HOST_WIDE_INT_MAX >> shift))
3076 : precision <= HOST_BITS_PER_WIDE_INT)
3078 val[0] = xi.ulow () << shift;
3082 result.set_len (lshift_large (val, xi.val, xi.len,
3088 /* Return X >> Y, using a logical shift. Return 0 if Y is greater than
3089 or equal to the precision of X. */
3090 template <typename T1, typename T2>
3091 inline WI_UNARY_RESULT (T1)
3092 wi::lrshift (const T1 &x, const T2 &y)
3094 WI_UNARY_RESULT_VAR (result, val, T1, x);
3095 /* Do things in the precision of the input rather than the output,
3096 since the result can be no larger than that. */
3097 WIDE_INT_REF_FOR (T1) xi (x);
3098 WIDE_INT_REF_FOR (T2) yi (y);
3099 /* Handle the simple cases quickly. */
3100 if (geu_p (yi, xi.precision))
3107 unsigned int shift = yi.to_uhwi ();
3108 /* For fixed-precision integers like offset_int and widest_int,
3109 handle the case where the shift value is constant and the
3110 shifted value is a single nonnegative HWI (meaning that all
3111 bits above the HWI are zero). This is particularly common
3112 for converting a bit count to a byte count.
3114 For variable-precision integers like wide_int, handle HWI
3115 and sub-HWI integers inline. */
3116 if (STATIC_CONSTANT_P (xi.precision > HOST_BITS_PER_WIDE_INT)
3117 ? (shift < HOST_BITS_PER_WIDE_INT
3120 : xi.precision <= HOST_BITS_PER_WIDE_INT)
3122 val[0] = xi.to_uhwi () >> shift;
3126 result.set_len (lrshift_large (val, xi.val, xi.len, xi.precision,
3127 get_precision (result), shift));
3132 /* Return X >> Y, using an arithmetic shift. Return a sign mask if
3133 Y is greater than or equal to the precision of X. */
3134 template <typename T1, typename T2>
3135 inline WI_UNARY_RESULT (T1)
3136 wi::arshift (const T1 &x, const T2 &y)
3138 WI_UNARY_RESULT_VAR (result, val, T1, x);
3139 /* Do things in the precision of the input rather than the output,
3140 since the result can be no larger than that. */
3141 WIDE_INT_REF_FOR (T1) xi (x);
3142 WIDE_INT_REF_FOR (T2) yi (y);
3143 /* Handle the simple cases quickly. */
3144 if (geu_p (yi, xi.precision))
3146 val[0] = sign_mask (x);
3151 unsigned int shift = yi.to_uhwi ();
3152 if (xi.precision <= HOST_BITS_PER_WIDE_INT)
3154 val[0] = sext_hwi (xi.ulow () >> shift, xi.precision - shift);
3155 result.set_len (1, true);
3158 result.set_len (arshift_large (val, xi.val, xi.len, xi.precision,
3159 get_precision (result), shift));
3164 /* Return X >> Y, using an arithmetic shift if SGN is SIGNED and a
3165 logical shift otherwise. */
3166 template <typename T1, typename T2>
3167 inline WI_UNARY_RESULT (T1)
3168 wi::rshift (const T1 &x, const T2 &y, signop sgn)
3170 if (sgn == UNSIGNED)
3171 return lrshift (x, y);
3173 return arshift (x, y);
3176 /* Return the result of rotating the low WIDTH bits of X left by Y
3177 bits and zero-extending the result. Use a full-width rotate if
3179 template <typename T1, typename T2>
3180 WI_UNARY_RESULT (T1)
3181 wi::lrotate (const T1 &x, const T2 &y, unsigned int width)
3183 unsigned int precision = get_binary_precision (x, x);
3186 WI_UNARY_RESULT (T2) ymod = umod_trunc (y, width);
3187 WI_UNARY_RESULT (T1) left = wi::lshift (x, ymod);
3188 WI_UNARY_RESULT (T1) right = wi::lrshift (x, wi::sub (width, ymod));
3189 if (width != precision)
3190 return wi::zext (left, width) | wi::zext (right, width);
3191 return left | right;
3194 /* Return the result of rotating the low WIDTH bits of X right by Y
3195 bits and zero-extending the result. Use a full-width rotate if
3197 template <typename T1, typename T2>
3198 WI_UNARY_RESULT (T1)
3199 wi::rrotate (const T1 &x, const T2 &y, unsigned int width)
3201 unsigned int precision = get_binary_precision (x, x);
3204 WI_UNARY_RESULT (T2) ymod = umod_trunc (y, width);
3205 WI_UNARY_RESULT (T1) right = wi::lrshift (x, ymod);
3206 WI_UNARY_RESULT (T1) left = wi::lshift (x, wi::sub (width, ymod));
3207 if (width != precision)
3208 return wi::zext (left, width) | wi::zext (right, width);
3209 return left | right;
3212 /* Return 0 if the number of 1s in X is even and 1 if the number of 1s
3215 wi::parity (const wide_int_ref &x)
3217 return popcount (x) & 1;
3220 /* Extract WIDTH bits from X, starting at BITPOS. */
3221 template <typename T>
3222 inline unsigned HOST_WIDE_INT
3223 wi::extract_uhwi (const T &x, unsigned int bitpos, unsigned int width)
3225 unsigned precision = get_precision (x);
3226 if (precision < bitpos + width)
3227 precision = bitpos + width;
3228 WIDE_INT_REF_FOR (T) xi (x, precision);
3230 /* Handle this rare case after the above, so that we assert about
3231 bogus BITPOS values. */
3235 unsigned int start = bitpos / HOST_BITS_PER_WIDE_INT;
3236 unsigned int shift = bitpos % HOST_BITS_PER_WIDE_INT;
3237 unsigned HOST_WIDE_INT res = xi.elt (start);
3239 if (shift + width > HOST_BITS_PER_WIDE_INT)
3241 unsigned HOST_WIDE_INT upper = xi.elt (start + 1);
3242 res |= upper << (-shift % HOST_BITS_PER_WIDE_INT);
3244 return zext_hwi (res, width);
3247 /* Return the minimum precision needed to store X with sign SGN. */
3248 template <typename T>
3250 wi::min_precision (const T &x, signop sgn)
3253 return get_precision (x) - clrsb (x);
3255 return get_precision (x) - clz (x);
3258 #define SIGNED_BINARY_PREDICATE(OP, F) \
3259 template <typename T1, typename T2> \
3260 inline WI_SIGNED_BINARY_PREDICATE_RESULT (T1, T2) \
3261 OP (const T1 &x, const T2 &y) \
3263 return wi::F (x, y); \
3266 SIGNED_BINARY_PREDICATE (operator <, lts_p)
3267 SIGNED_BINARY_PREDICATE (operator <=, les_p)
3268 SIGNED_BINARY_PREDICATE (operator >, gts_p)
3269 SIGNED_BINARY_PREDICATE (operator >=, ges_p)
3271 #undef SIGNED_BINARY_PREDICATE
3273 #define UNARY_OPERATOR(OP, F) \
3274 template<typename T> \
3275 WI_UNARY_RESULT (generic_wide_int<T>) \
3276 OP (const generic_wide_int<T> &x) \
3281 #define BINARY_PREDICATE(OP, F) \
3282 template<typename T1, typename T2> \
3283 WI_BINARY_PREDICATE_RESULT (T1, T2) \
3284 OP (const T1 &x, const T2 &y) \
3286 return wi::F (x, y); \
3289 #define BINARY_OPERATOR(OP, F) \
3290 template<typename T1, typename T2> \
3291 WI_BINARY_OPERATOR_RESULT (T1, T2) \
3292 OP (const T1 &x, const T2 &y) \
3294 return wi::F (x, y); \
3297 #define SHIFT_OPERATOR(OP, F) \
3298 template<typename T1, typename T2> \
3299 WI_BINARY_OPERATOR_RESULT (T1, T1) \
3300 OP (const T1 &x, const T2 &y) \
3302 return wi::F (x, y); \
3305 UNARY_OPERATOR (operator ~, bit_not)
3306 UNARY_OPERATOR (operator -, neg)
3307 BINARY_PREDICATE (operator ==, eq_p)
3308 BINARY_PREDICATE (operator !=, ne_p)
3309 BINARY_OPERATOR (operator &, bit_and)
3310 BINARY_OPERATOR (operator |, bit_or)
3311 BINARY_OPERATOR (operator ^, bit_xor)
3312 BINARY_OPERATOR (operator +, add)
3313 BINARY_OPERATOR (operator -, sub)
3314 BINARY_OPERATOR (operator *, mul)
3315 SHIFT_OPERATOR (operator <<, lshift)
3317 #undef UNARY_OPERATOR
3318 #undef BINARY_PREDICATE
3319 #undef BINARY_OPERATOR
3320 #undef SHIFT_OPERATOR
3322 template <typename T1, typename T2>
3323 inline WI_SIGNED_SHIFT_RESULT (T1, T2)
3324 operator >> (const T1 &x, const T2 &y)
3326 return wi::arshift (x, y);
3329 template <typename T1, typename T2>
3330 inline WI_SIGNED_SHIFT_RESULT (T1, T2)
3331 operator / (const T1 &x, const T2 &y)
3333 return wi::sdiv_trunc (x, y);
3336 template <typename T1, typename T2>
3337 inline WI_SIGNED_SHIFT_RESULT (T1, T2)
3338 operator % (const T1 &x, const T2 &y)
3340 return wi::smod_trunc (x, y);
3343 template<typename T>
3345 gt_ggc_mx (generic_wide_int <T> *)
3349 template<typename T>
3351 gt_pch_nx (generic_wide_int <T> *)
3355 template<typename T>
3357 gt_pch_nx (generic_wide_int <T> *, gt_pointer_operator, void *)
3363 gt_ggc_mx (trailing_wide_ints <N> *)
3369 gt_pch_nx (trailing_wide_ints <N> *)
3375 gt_pch_nx (trailing_wide_ints <N> *, gt_pointer_operator, void *)
3381 /* Used for overloaded functions in which the only other acceptable
3382 scalar type is a pointer. It stops a plain 0 from being treated
3383 as a null pointer. */
3384 struct never_used1 {};
3385 struct never_used2 {};
3387 wide_int min_value (unsigned int, signop);
3388 wide_int min_value (never_used1 *);
3389 wide_int min_value (never_used2 *);
3390 wide_int max_value (unsigned int, signop);
3391 wide_int max_value (never_used1 *);
3392 wide_int max_value (never_used2 *);
3394 /* FIXME: this is target dependent, so should be elsewhere.
3395 It also seems to assume that CHAR_BIT == BITS_PER_UNIT. */
3396 wide_int from_buffer (const unsigned char *, unsigned int);
3398 #ifndef GENERATOR_FILE
3399 void to_mpz (const wide_int_ref &, mpz_t, signop);
3402 wide_int mask (unsigned int, bool, unsigned int);
3403 wide_int shifted_mask (unsigned int, unsigned int, bool, unsigned int);
3404 wide_int set_bit_in_zero (unsigned int, unsigned int);
3405 wide_int insert (const wide_int &x, const wide_int &y, unsigned int,
3407 wide_int round_down_for_mask (const wide_int &, const wide_int &);
3408 wide_int round_up_for_mask (const wide_int &, const wide_int &);
3410 wide_int mod_inv (const wide_int &a, const wide_int &b);
3412 template <typename T>
3413 T mask (unsigned int, bool);
3415 template <typename T>
3416 T shifted_mask (unsigned int, unsigned int, bool);
3418 template <typename T>
3419 T set_bit_in_zero (unsigned int);
3421 unsigned int mask (HOST_WIDE_INT *, unsigned int, bool, unsigned int);
3422 unsigned int shifted_mask (HOST_WIDE_INT *, unsigned int, unsigned int,
3423 bool, unsigned int);
3424 unsigned int from_array (HOST_WIDE_INT *, const HOST_WIDE_INT *,
3425 unsigned int, unsigned int, bool);
3428 /* Return a PRECISION-bit integer in which the low WIDTH bits are set
3429 and the other bits are clear, or the inverse if NEGATE_P. */
3431 wi::mask (unsigned int width, bool negate_p, unsigned int precision)
3433 wide_int result = wide_int::create (precision);
3434 result.set_len (mask (result.write_val (), width, negate_p, precision));
3438 /* Return a PRECISION-bit integer in which the low START bits are clear,
3439 the next WIDTH bits are set, and the other bits are clear,
3440 or the inverse if NEGATE_P. */
3442 wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p,
3443 unsigned int precision)
3445 wide_int result = wide_int::create (precision);
3446 result.set_len (shifted_mask (result.write_val (), start, width, negate_p,
3451 /* Return a PRECISION-bit integer in which bit BIT is set and all the
3452 others are clear. */
3454 wi::set_bit_in_zero (unsigned int bit, unsigned int precision)
3456 return shifted_mask (bit, 1, false, precision);
3459 /* Return an integer of type T in which the low WIDTH bits are set
3460 and the other bits are clear, or the inverse if NEGATE_P. */
3461 template <typename T>
3463 wi::mask (unsigned int width, bool negate_p)
3465 STATIC_ASSERT (wi::int_traits<T>::precision);
3467 result.set_len (mask (result.write_val (), width, negate_p,
3468 wi::int_traits <T>::precision));
3472 /* Return an integer of type T in which the low START bits are clear,
3473 the next WIDTH bits are set, and the other bits are clear, or the
3474 inverse if NEGATE_P. */
3475 template <typename T>
3477 wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p)
3479 STATIC_ASSERT (wi::int_traits<T>::precision);
3481 result.set_len (shifted_mask (result.write_val (), start, width,
3483 wi::int_traits <T>::precision));
3487 /* Return an integer of type T in which bit BIT is set and all the
3488 others are clear. */
3489 template <typename T>
3491 wi::set_bit_in_zero (unsigned int bit)
3493 return shifted_mask <T> (bit, 1, false);
3496 /* Accumulate a set of overflows into OVERFLOW. */
3499 wi::accumulate_overflow (wi::overflow_type &overflow,
3500 wi::overflow_type suboverflow)
3505 overflow = suboverflow;
3506 else if (overflow != suboverflow)
3507 overflow = wi::OVF_UNKNOWN;
3510 #endif /* WIDE_INT_H */