Go to the source code of this file.
Namespaces | |
| namespace | wi |
Enumerations | |
| enum | wi::overflow_type { wi::OVF_NONE = 0 , wi::OVF_UNDERFLOW = -1 , wi::OVF_OVERFLOW = 1 , wi::OVF_UNKNOWN = 2 } |
| enum | wi::precision_type { wi::FLEXIBLE_PRECISION , wi::VAR_PRECISION , wi::INL_CONST_PRECISION , wi::CONST_PRECISION } |
Variables | |
| const T2 & | y |
Macro Definition Documentation
◆ ADDR_MAX_BITSIZE
| #define ADDR_MAX_BITSIZE 64 |
This is the max size of any pointer on any machine. It does not seem to be as easy to sniff this out of the machine description as it is for MAX_BITSIZE_MODE_ANY_INT since targets may support multiple address sizes and may have different address sizes for different address spaces. However, currently the largest pointer on any platform is 64 bits. When that changes, then it is likely that a target hook should be defined so that targets can make this value larger for those targets.
Referenced by get_ref_base_and_extent().
◆ ADDR_MAX_PRECISION
| #define ADDR_MAX_PRECISION |
This is the internal precision used when doing any address arithmetic. The '4' is really 3 + 1. Three of the bits are for the number of extra bits needed to do bit addresses and the other bit is to allow everything to be signed without loosing any precision. Then everything is rounded up to the next HWI for efficiency.
Referenced by wi::extended_tree< N >::get_len(), and gimple_call_alloc_size().
◆ ASSIGNMENT_OPERATOR
◆ BINARY_FUNCTION
◆ BINARY_OPERATOR
◆ BINARY_PREDICATE [1/2]
◆ BINARY_PREDICATE [2/2]
◆ FIXED_WIDE_INT
| #define FIXED_WIDE_INT | ( | N | ) | generic_wide_int < fixed_wide_int_storage <N> > |
An N-bit integer. Until we can use typedef templates, use this instead.
Referenced by FIXED_WIDE_INT(), FIXED_WIDE_INT(), fixed_wide_int_storage< N >::fixed_wide_int_storage(), and slow_safe_scale_64bit().
◆ INCDEC_OPERATOR
◆ OFFSET_INT_ELTS
| #define OFFSET_INT_ELTS (ADDR_MAX_PRECISION / HOST_BITS_PER_WIDE_INT) |
The number of HWIs needed to store an offset_int.
Referenced by wi::extended_tree< N >::get_len().
◆ SHIFT_ASSIGNMENT_OPERATOR
Restrict these to cases where the shift operator is defined.
◆ SHIFT_FUNCTION
◆ SHIFT_OPERATOR
◆ SIGNED_BINARY_PREDICATE
◆ TRAILING_WIDE_INT_ACCESSOR
This macro is used in structures that end with a trailing_wide_ints field called FIELD. It declares get_NAME() and set_NAME() methods to access element I of FIELD.
◆ UNARY_FUNCTION
| #define UNARY_FUNCTION template <typename T> WI_UNARY_RESULT (T) |
◆ UNARY_OPERATOR
◆ UNARY_PREDICATE
◆ WI_BINARY_OPERATOR_RESULT
Likewise for binary operators, which excludes the case in which neither T1 nor T2 is a wide-int-based type.
◆ WI_BINARY_PREDICATE_RESULT
The type of result produced by a sign-agnostic binary predicate on types T1 and T2. This is bool if wide-int operations make sense for T1 and T2 and leads to substitution failure otherwise.
◆ WI_BINARY_RESULT
The type of result produced by a binary operation on types T1 and T2. Defined purely for brevity.
Referenced by fixed_wide_int_storage< N >::fixed_wide_int_storage(), wi::get_binary_precision(), wi::multiple_of_p(), widest_int_storage< N >::operator=(), and widest_int_storage< N >::widest_int_storage().
◆ WI_BINARY_RESULT_VAR
Define a variable RESULT to hold the result of a binary operation on X and Y, which have types T1 and T2 respectively. Define VAL to point to the blocks of RESULT. Once the user of the macro has filled in VAL, it should call RESULT.set_len to set the number of initialized blocks.
Referenced by WI_BINARY_RESULT().
◆ WI_SIGNED_BINARY_PREDICATE_RESULT
| #define WI_SIGNED_BINARY_PREDICATE_RESULT | ( | T1, | |
| T2 ) typename wi::binary_traits <T1, T2>::signed_predicate_result |
The type of result produced by a signed binary predicate on types T1 and T2. This is bool if signed comparisons make sense for T1 and T2 and leads to substitution failure otherwise.
◆ WI_SIGNED_SHIFT_RESULT
| #define WI_SIGNED_SHIFT_RESULT | ( | T1, | |
| T2 ) typename wi::binary_traits <T1, T2>::signed_shift_result_type |
The type of result produced by T1 << T2. Leads to substitution failure if the operation isn't supported. Defined purely for brevity.
◆ WI_UNARY_RESULT
| #define WI_UNARY_RESULT | ( | T | ) | typename wi::binary_traits <T, T>::result_type |
The type of result produced by a unary operation on type T.
◆ WI_UNARY_RESULT_VAR
Similar for the result of a unary operation on X, which has type T.
Referenced by WI_UNARY_RESULT(), and WI_UNARY_RESULT().
◆ WIDE_INT_MAX_ELTS
| #define WIDE_INT_MAX_ELTS 1024 |
Precision of wide_int and largest _BitInt precision + 1 we can support.
◆ WIDE_INT_MAX_HWIS
| #define WIDE_INT_MAX_HWIS | ( | PRECISION | ) | ((PRECISION + HOST_BITS_PER_WIDE_INT - 1) / HOST_BITS_PER_WIDE_INT) |
The max number of HWIs needed to store a wide_int of PRECISION.
Referenced by trailing_wide_ints< N >::extra_size(), omp_lto_input_declare_variant_alt(), print_dec_buf_size(), print_hex_buf_size(), trailing_wide_ints< N >::set_precision(), irange_storage::size(), and irange_storage::write_lengths_address().
◆ WIDE_INT_MAX_INL_ELTS
| #define WIDE_INT_MAX_INL_ELTS |
Operations with very long integers. -*- C++ -*- Copyright (C) 2012-2024 Free Software Foundation, Inc. This file is part of GCC. GCC is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GCC is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GCC; see the file COPYING3. If not see <http://www.gnu.org/licenses/>.
wide-int.[cc|h] implements a class that efficiently performs
mathematical operations on finite precision integers. wide_ints
are designed to be transient - they are not for long term storage
of values. There is tight integration between wide_ints and the
other longer storage GCC representations (rtl and tree).
The actual precision of a wide_int depends on the flavor. There
are three predefined flavors:
1) wide_int (the default). This flavor does the math in the
precision of its input arguments. It is assumed (and checked)
that the precisions of the operands and results are consistent.
This is the most efficient flavor. It is not possible to examine
bits above the precision that has been specified. Because of
this, the default flavor has semantics that are simple to
understand and in general model the underlying hardware that the
compiler is targetted for.
This flavor must be used at the RTL level of gcc because there
is, in general, not enough information in the RTL representation
to extend a value beyond the precision specified in the mode.
This flavor should also be used at the TREE and GIMPLE levels of
the compiler except for the circumstances described in the
descriptions of the other two flavors.
The default wide_int representation does not contain any
information inherent about signedness of the represented value,
so it can be used to represent both signed and unsigned numbers.
For operations where the results depend on signedness (full width
multiply, division, shifts, comparisons, and operations that need
overflow detected), the signedness must be specified separately.
For precisions up to WIDE_INT_MAX_INL_PRECISION, it uses an inline
buffer in the type, for larger precisions up to WIDEST_INT_MAX_PRECISION
it uses a pointer to heap allocated buffer.
2) offset_int. This is a fixed-precision integer that can hold
any address offset, measured in either bits or bytes, with at
least one extra sign bit. At the moment the maximum address
size GCC supports is 64 bits. With 8-bit bytes and an extra
sign bit, offset_int therefore needs to have at least 68 bits
of precision. We round this up to 128 bits for efficiency.
Values of type T are converted to this precision by sign- or
zero-extending them based on the signedness of T.
The extra sign bit means that offset_int is effectively a signed
128-bit integer, i.e. it behaves like int128_t.
Since the values are logically signed, there is no need to
distinguish between signed and unsigned operations. Sign-sensitive
comparison operators <, <=, > and >= are therefore supported.
Shift operators << and >> are also supported, with >> being
an _arithmetic_ right shift.
[ Note that, even though offset_int is effectively int128_t,
it can still be useful to use unsigned comparisons like
wi::leu_p (a, b) as a more efficient short-hand for
"a >= 0 && a <= b". ]
3) widest_int. This representation is an approximation of
infinite precision math. However, it is not really infinite
precision math as in the GMP library. It is really finite
precision math where the precision is WIDEST_INT_MAX_PRECISION.
Like offset_int, widest_int is wider than all the values that
it needs to represent, so the integers are logically signed.
Sign-sensitive comparison operators <, <=, > and >= are supported,
as are << and >>.
There are several places in the GCC where this should/must be used:
* Code that does induction variable optimizations. This code
works with induction variables of many different types at the
same time. Because of this, it ends up doing many different
calculations where the operands are not compatible types. The
widest_int makes this easy, because it provides a field where
nothing is lost when converting from any variable,
* There are a small number of passes that currently use the
widest_int that should use the default. These should be
changed.
There are surprising features of offset_int and widest_int
that the users should be careful about:
1) Shifts and rotations are just weird. You have to specify a
precision in which the shift or rotate is to happen in. The bits
above this precision are zeroed. While this is what you
want, it is clearly non obvious.
2) Larger precision math sometimes does not produce the same
answer as would be expected for doing the math at the proper
precision. In particular, a multiply followed by a divide will
produce a different answer if the first product is larger than
what can be represented in the input precision.
The offset_int and the widest_int flavors are more expensive
than the default wide int, so in addition to the caveats with these
two, the default is the prefered representation.
All three flavors of wide_int are represented as a vector of
HOST_WIDE_INTs. The default and widest_int vectors contain enough elements
to hold a value of MAX_BITSIZE_MODE_ANY_INT bits. offset_int contains only
enough elements to hold ADDR_MAX_PRECISION bits. The values are stored
in the vector with the least significant HOST_BITS_PER_WIDE_INT bits
in element 0.
The default wide_int contains three fields: the vector (VAL),
the precision and a length (LEN). The length is the number of HWIs
needed to represent the value. widest_int and offset_int have a
constant precision that cannot be changed, so they only store the
VAL and LEN fields.
Since most integers used in a compiler are small values, it is
generally profitable to use a representation of the value that is
as small as possible. LEN is used to indicate the number of
elements of the vector that are in use. The numbers are stored as
sign extended numbers as a means of compression. Leading
HOST_WIDE_INTs that contain strings of either -1 or 0 are removed
as long as they can be reconstructed from the top bit that is being
represented.
The precision and length of a wide_int are always greater than 0.
Any bits in a wide_int above the precision are sign-extended from the
most significant bit. For example, a 4-bit value 0x8 is represented as
VAL = { 0xf...fff8 }. However, as an optimization, we allow other integer
constants to be represented with undefined bits above the precision.
This allows INTEGER_CSTs to be pre-extended according to TYPE_SIGN,
so that the INTEGER_CST representation can be used both in TYPE_PRECISION
and in wider precisions.
There are constructors to create the various forms of wide_int from
trees, rtl and constants. For trees the options are:
tree t = ...;
wi::to_wide (t) // Treat T as a wide_int
wi::to_offset (t) // Treat T as an offset_int
wi::to_widest (t) // Treat T as a widest_int
All three are light-weight accessors that should have no overhead
in release builds. If it is useful for readability reasons to
store the result in a temporary variable, the preferred method is:
wi::tree_to_wide_ref twide = wi::to_wide (t);
wi::tree_to_offset_ref toffset = wi::to_offset (t);
wi::tree_to_widest_ref twidest = wi::to_widest (t);
To make an rtx into a wide_int, you have to pair it with a mode.
The canonical way to do this is with rtx_mode_t as in:
rtx r = ...
wide_int x = rtx_mode_t (r, mode);
Similarly, a wide_int can only be constructed from a host value if
the target precision is given explicitly, such as in:
wide_int x = wi::shwi (c, prec); // sign-extend C if necessary
wide_int y = wi::uhwi (c, prec); // zero-extend C if necessary
However, offset_int and widest_int have an inherent precision and so
can be initialized directly from a host value:
offset_int x = (int) c; // sign-extend C
widest_int x = (unsigned int) c; // zero-extend C
It is also possible to do arithmetic directly on rtx_mode_ts and
constants. For example:
wi::add (r1, r2); // add equal-sized rtx_mode_ts r1 and r2
wi::add (r1, 1); // add 1 to rtx_mode_t r1
wi::lshift (1, 100); // 1 << 100 as a widest_int
Many binary operations place restrictions on the combinations of inputs,
using the following rules:
- {rtx, wide_int} op {rtx, wide_int} -> wide_int
The inputs must be the same precision. The result is a wide_int
of the same precision
- {rtx, wide_int} op (un)signed HOST_WIDE_INT -> wide_int
(un)signed HOST_WIDE_INT op {rtx, wide_int} -> wide_int
The HOST_WIDE_INT is extended or truncated to the precision of
the other input. The result is a wide_int of the same precision
as that input.
- (un)signed HOST_WIDE_INT op (un)signed HOST_WIDE_INT -> widest_int
The inputs are extended to widest_int precision and produce a
widest_int result.
- offset_int op offset_int -> offset_int
offset_int op (un)signed HOST_WIDE_INT -> offset_int
(un)signed HOST_WIDE_INT op offset_int -> offset_int
- widest_int op widest_int -> widest_int
widest_int op (un)signed HOST_WIDE_INT -> widest_int
(un)signed HOST_WIDE_INT op widest_int -> widest_int
Other combinations like:
- widest_int op offset_int and
- wide_int op offset_int
are not allowed. The inputs should instead be extended or truncated
so that they match.
The inputs to comparison functions like wi::eq_p and wi::lts_p
follow the same compatibility rules, although their return types
are different. Unary functions on X produce the same result as
a binary operation X + X. Shift functions X op Y also produce
the same result as X + X; the precision of the shift amount Y
can be arbitrarily different from X. The MAX_BITSIZE_MODE_ANY_INT is automatically generated by a very early examination of the target's mode file. The WIDE_INT_MAX_INL_ELTS can accomodate at least 1 more bit so that unsigned numbers of that mode can be represented as a signed value. Note that it is still possible to create fixed_wide_ints that have precisions greater than MAX_BITSIZE_MODE_ANY_INT. This can be useful when representing a double-width multiplication result, for example.
Referenced by build_replicated_int_cst(), pass_walloca::execute(), wi::from_mpz(), widest_int_storage< N >::get_val(), go_output_typedef(), lto_input_tree_1(), widest_int_storage< N >::operator=(), widest_int_storage< N >::operator=(), real_to_integer(), widest_int_storage< N >::set_len(), streamer_read_wide_int(), streamer_read_widest_int(), widest_int_storage< N >::widest_int_storage(), widest_int_storage< N >::write_val(), and widest_int_storage< N >::~widest_int_storage().
◆ WIDE_INT_MAX_INL_PRECISION
| #define WIDE_INT_MAX_INL_PRECISION (WIDE_INT_MAX_INL_ELTS * HOST_BITS_PER_WIDE_INT) |
Referenced by wide_int_storage::create(), wi::divmod_internal(), pass_walloca::execute(), wide_int_storage::get_val(), wi::mul_internal(), wide_int_storage::operator=(), wide_int_storage::operator=(), wide_int_storage::wide_int_storage(), wide_int_storage::wide_int_storage(), wide_int_storage::write_val(), and wide_int_storage::~wide_int_storage().
◆ WIDE_INT_MAX_PRECISION
| #define WIDE_INT_MAX_PRECISION (WIDE_INT_MAX_ELTS * HOST_BITS_PER_WIDE_INT) |
Referenced by create_access(), fold_view_convert_expr(), lto_input_tree_1(), and set_min_and_max_values_for_integral_type().
◆ WIDE_INT_REF_FOR
| #define WIDE_INT_REF_FOR | ( | T | ) |
This can be used instead of wide_int_ref if the referenced value is known to have type T. It carries across properties of T's representation, such as whether excess upper bits in a HWI are defined, and can therefore help avoid redundant work. The macro could be replaced with a template typedef, once we're able to use those.
Referenced by wi::cmps(), wi::cmpu(), const_poly_int_value(), wi::extract_uhwi(), fixed_wide_int_storage< N >::fixed_wide_int_storage(), wide_int_storage::operator=(), trailing_wide_int_storage::operator=(), widest_int_storage< N >::operator=(), wi::sign_mask(), WI_BINARY_RESULT(), WI_UNARY_RESULT(), WI_UNARY_RESULT(), wide_int_storage::wide_int_storage(), and widest_int_storage< N >::widest_int_storage().
◆ WIDEST_INT
| #define WIDEST_INT | ( | N | ) | generic_wide_int < widest_int_storage <N> > |
◆ WIDEST_INT_MAX_ELTS
| #define WIDEST_INT_MAX_ELTS 2048 |
Precision of widest_int.
◆ WIDEST_INT_MAX_PRECISION
| #define WIDEST_INT_MAX_PRECISION (WIDEST_INT_MAX_ELTS * HOST_BITS_PER_WIDE_INT) |
Referenced by wi::extended_tree< N >::get_len().
Typedef Documentation
◆ trailing_wide_int
◆ wide_int
◆ wide_int_ref
◆ widest2_int
◆ widest_int
Function Documentation
◆ FIXED_WIDE_INT() [1/3]
| typedef FIXED_WIDE_INT | ( | ADDR_MAX_PRECISION | ) |
◆ FIXED_WIDE_INT() [2/3]
|
inline |
Treat X as having signedness SGN and convert it to an N-bit number.
Create a FIXED_WIDE_INT (N) from the explicit block encoding given by VAL and LEN. NEED_CANON_P is true if the encoding may have redundant trailing blocks.
References FIXED_WIDE_INT, wi::force_to_size(), and N.
◆ FIXED_WIDE_INT() [3/3]
◆ gt_ggc_mx() [1/4]
| void gt_ggc_mx | ( | generic_wide_int< fixed_wide_int_storage< N > > * | ) |
◆ gt_ggc_mx() [2/4]
|
delete |
◆ gt_ggc_mx() [3/4]
|
delete |
◆ gt_ggc_mx() [4/4]
| void gt_ggc_mx | ( | trailing_wide_ints< N > * | ) |
◆ gt_pch_nx() [1/8]
| void gt_pch_nx | ( | generic_wide_int< fixed_wide_int_storage< N > > * | ) |
◆ gt_pch_nx() [2/8]
| void gt_pch_nx | ( | generic_wide_int< fixed_wide_int_storage< N > > * | , |
| gt_pointer_operator | , | ||
| void * | ) |
◆ gt_pch_nx() [3/8]
|
delete |
◆ gt_pch_nx() [4/8]
|
delete |
◆ gt_pch_nx() [5/8]
|
delete |
◆ gt_pch_nx() [6/8]
|
delete |
◆ gt_pch_nx() [7/8]
| void gt_pch_nx | ( | trailing_wide_ints< N > * | ) |
◆ gt_pch_nx() [8/8]
| void gt_pch_nx | ( | trailing_wide_ints< N > * | , |
| gt_pointer_operator | , | ||
| void * | ) |
◆ STATIC_ASSERT()
| STATIC_ASSERT | ( | ) |
◆ WI_BINARY_RESULT()
Return the mininum of X and Y, treating them both as having signedness SGN.
Return the minimum of X and Y, treating both as signed values.
Return the minimum of X and Y, treating both as unsigned values.
Return the maxinum of X and Y, treating them both as having signedness SGN.
Return the maximum of X and Y, treating both as signed values.
Return the maximum of X and Y, treating both as unsigned values.
Return X & Y.
Return X & ~Y.
Return X | Y.
Return X | ~Y.
Return X ^ Y.
Return X + Y.
Return X + Y. Treat X and Y as having the signednes given by SGN and indicate in *OVERFLOW whether the operation overflowed.
Return X - Y.
Return X - Y. Treat X and Y as having the signednes given by SGN and indicate in *OVERFLOW whether the operation overflowed.
Return X * Y.
Return X * Y. Treat X and Y as having the signednes given by SGN and indicate in *OVERFLOW whether the operation overflowed.
Return X * Y, treating both X and Y as signed values. Indicate in *OVERFLOW whether the operation overflowed.
Return X * Y, treating both X and Y as unsigned values. Indicate in *OVERFLOW if the result overflows.
Perform a widening multiplication of X and Y, extending the values according to SGN, and return the high part of the result.
Return X / Y, rouding towards 0. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the result overflows.
Return X / Y, rouding towards 0. Treat X and Y as signed values.
Return X / Y, rouding towards 0. Treat X and Y as unsigned values.
Return X / Y, rouding towards -inf. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the result overflows.
Return X / Y, rouding towards -inf. Treat X and Y as signed values.
Return X / Y, rouding towards -inf. Treat X and Y as unsigned values.
??? Why do we have both this and udiv_trunc. Aren't they the same?
Return X / Y, rouding towards +inf. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the result overflows.
Return X / Y, rouding towards +inf. Treat X and Y as unsigned values.
Return X / Y, rouding towards nearest with ties away from zero. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the result overflows.
Return X / Y, rouding towards 0. Treat X and Y as having the signedness given by SGN. Store the remainder in *REMAINDER_PTR.
Compute the greatest common divisor of two numbers A and B using Euclid's algorithm.
Compute X / Y, rouding towards 0, and return the remainder. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the division overflows.
Compute X / Y, rouding towards 0, and return the remainder. Treat X and Y as signed values.
Compute X / Y, rouding towards 0, and return the remainder. Treat X and Y as unsigned values.
Compute X / Y, rouding towards -inf, and return the remainder. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the division overflows.
Compute X / Y, rouding towards -inf, and return the remainder. Treat X and Y as unsigned values.
??? Why do we have both this and umod_trunc. Aren't they the same?
Compute X / Y, rouding towards +inf, and return the remainder. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the division overflows.
Compute X / Y, rouding towards nearest with ties away from zero, and return the remainder. Treat X and Y as having the signedness given by SGN. Indicate in *OVERFLOW if the division overflows.
References wi::copy(), wi::get_precision(), ggc_alloc(), wi::le_p(), wi::precision, WI_BINARY_RESULT_VAR, WIDE_INT_REF_FOR, and y.
◆ WI_SIGNED_SHIFT_RESULT()
◆ WI_UNARY_RESULT() [1/2]
Return ~x.
Return -x.
Return -x. Indicate in *OVERFLOW if performing the negation would cause an overflow.
Return the absolute value of x.
Return the result of sign-extending the low OFFSET bits of X.
Return the result of zero-extending the low OFFSET bits of X.
Return the result of extending the low OFFSET bits of X according to signedness SGN.
Return an integer that represents X | (1 << bit).
Byte swap the integer X. ??? This always swaps 8-bit octets, regardless of BITS_PER_UNIT. This function requires X's precision to be a multiple of 16 bits, so care needs to be taken for targets where BITS_PER_UNIT != 8.
Bitreverse the integer X.
References wi::get_precision(), ggc_alloc(), wi::i, WI_UNARY_RESULT_VAR, and WIDE_INT_REF_FOR.
◆ WI_UNARY_RESULT() [2/2]
Return X << Y. Return 0 if Y is greater than or equal to the precision of X.
Return X >> Y, using a logical shift. Return 0 if Y is greater than or equal to the precision of X.
Return X >> Y, using an arithmetic shift. Return a sign mask if Y is greater than or equal to the precision of X.
Return X >> Y, using an arithmetic shift if SGN is SIGNED and a logical shift otherwise.
References wi::get_precision(), wi::geu_p(), ggc_alloc(), HOST_BITS_PER_WIDE_INT, HOST_WIDE_INT_MAX, IN_RANGE, wi::lshift_large(), wi::precision, shift, STATIC_CONSTANT_P, WI_UNARY_RESULT_VAR, WIDE_INT_REF_FOR, and y.
◆ WIDEST_INT() [1/2]
◆ WIDEST_INT() [2/2]
|
inline |
Treat X as having signedness SGN and convert it to an N-bit number.
Create a WIDEST_INT (N) from the explicit block encoding given by VAL and LEN. NEED_CANON_P is true if the encoding may have redundant trailing blocks.
References CEIL, wi::force_to_size(), ggc_alloc(), HOST_BITS_PER_WIDE_INT, N, UNSIGNED, and WIDEST_INT.
Variable Documentation
◆ y
Referenced by add_stack_var_conflict(), alter_subreg(), attempt_coalesce(), attr_equal_p(), base_alias_check(), bb_top_order_cmp_r(), bound_difference(), bound_difference_of_offsetted_base(), canonicalize_insn(), fibonacci_heap< K, V >::cascading_cut(), change_zero_ext(), wi::cmp(), cmp_c_test(), wi::cmps(), wi::cmpu(), coalesce_partitions(), compare_address_parts(), compare_candidates(), compare_reg_or_pc(), compress_float_constant(), fibonacci_heap< K, V >::consolidate(), wi::copy(), copy_replacements(), copy_replacements_1(), coverage_checksum_string(), cse_insn(), debug_ter(), determine_dominators_for_sons(), range_def_chain::dump(), dump_location_info(), dump_part_var_map(), dump_var_map(), elim_graph_remove_succ_edge(), emit_add2_insn(), emit_add3_insn(), emit_block_cmp_hints(), emit_block_cmp_via_cmpmem(), emit_block_cmp_via_loop(), emit_block_move(), emit_block_move_hints(), emit_block_move_via_loop(), emit_block_move_via_oriented_loop(), emit_block_move_via_pattern(), emit_block_move_via_sized_loop(), emit_cmp_and_jump_insns(), emit_cmp_and_jump_insns(), emit_cstore(), emit_move_ccmode(), emit_move_complex(), emit_move_complex_parts(), emit_move_complex_push(), emit_move_insn(), emit_move_insn_1(), emit_move_multi_word(), emit_move_via_integer(), dw_loc_list_hasher::equal(), cgraph_edge_hasher::equal(), inline_entry_data_hasher::equal(), pair_hash< T1, T2 >::equal(), variable_hasher::equal(), const_rtx_desc_hasher::equal(), const_rtx_data_hasher::equal(), decl_die_hasher::equal(), omp_declare_variant_hasher::equal(), omp_declare_variant_alt_hasher::equal(), reg_attr_hasher::equal(), const_int_hasher::equal(), const_poly_int_hasher::equal(), const_double_hasher::equal(), const_fixed_hasher::equal(), insn_hasher::equal(), int_cst_hasher::equal(), cl_option_hasher::equal(), int_hash_base< Type >::equal(), vec_hash_base< Type >::equal(), decl_loc_hasher::equal(), unbounded_hashmap_traits< Key, Value >::equal_keys(), equiv_constant(), exp_equiv_p(), expr_equiv_p(), fibonacci_heap< K, V >::extract_minimum_node(), fail_abnormal_edge_coalesce(), finalize_nesting_tree_1(), find_replacement(), find_sets_in_insn(), range_operator::fold_range(), fold_rtx(), fold_to_nonsharp_ineq_using_bound(), force_int_to_mode(), form_sum(), form_sum(), gcd(), gen_add2_insn(), gen_addptr3_insn(), gen_extend_insn(), gen_move_insn(), gen_sub2_insn(), general_operand(), wi::get_binary_precision(), wi::int_traits< wide_int_storage >::get_binary_precision(), wi::int_traits< wide_int_storage >::get_binary_result(), hard_reg_set_intersect_p(), hard_reg_set_subset_p(), have_add2_insn(), have_addptr3_insn(), have_sub2_insn(), histogram_eq(), immune_p(), wi::insert(), invalidate_from_clobbers(), invalidate_from_sets_and_clobbers(), invert_mod2n(), iterate_fix_dominators(), lhd_types_compatible_p(), loc_cmp(), lower_omp_for_scan(), lower_rec_input_clauses(), lra_emit_add(), lra_emit_move(), lra_substitute_pseudo(), mask_with_tz(), maybe_trim_complex_store(), memory_address_addr_space(), memory_load_overlap(), memrefs_conflict_p(), merge_memattrs(), move_marked_base_types(), move_replacements(), mul_hwi(), mul_mod(), wi::multiple_of_p(), wi::multiple_of_p(), noce_convert_multiple_sets(), noce_emit_move_insn(), noce_try_move(), nonoverlapping_component_refs_p(), nonoverlapping_memrefs_p(), offsettable_address_addr_space_p(), operands_match_p(), operands_match_p(), output_object_block_compare(), permute_vec_elements(), plus_constant(), pos_mul_hwi(), prepare_cmp_insn(), prepare_float_lib_cmp(), propagate_bits(), propagate_nothrow(), propagate_pure_const(), real_nextafter(), const_and_copies::record_const_or_copy(), const_and_copies::record_const_or_copy(), const_and_copies::record_const_or_copy_raw(), record_equality(), fibonacci_heap< K, V >::replace_key_data(), rtl_verify_bb_layout(), rtx_equal_for_cselib_1(), rtx_equal_for_cselib_p(), rtx_equal_for_field_assignment_p(), rtx_equal_for_memref_p(), rtx_equal_p(), rtx_referenced_p(), rtx_renumbered_equal_p(), same_vector_encodings_p(), sbitmap_vector_alloc(), scratch_equal(), set_reg_attrs_for_decl_rtl(), simplify_context::simplify_binary_operation_1(), simplify_plus_minus_op_data_cmp(), single_pred_before_succ_order(), ssa_conflicts_add(), ssa_conflicts_add_one(), ssa_conflicts_merge(), ssa_conflicts_test_p(), stack_protect_epilogue(), stack_protect_prologue(), stack_var_conflict_p(), struct_ptr_eq(), swap_commutative_operands_p(), tm_alias_pair_cmp(), tree_nca(), try_eliminate_compare(), try_emit_cmove_seq(), union_static_var_sets(), values_equal_for_ipcp_p(), values_equal_for_ipcp_p(), WI_BINARY_RESULT(), and WI_UNARY_RESULT().
