poly_int: rtx constants
This patch adds an rtl representation of poly_int values.
There were three possible ways of doing this:
(1) Add a new rtl code for the poly_ints themselves and store the
coefficients as trailing wide_ints. This would give constants like:
(const_poly_int [c0 c1 ... cn])
The runtime value would be:
c0 + c1 * x1 + ... + cn * xn
(2) Like (1), but use rtxes for the coefficients. This would give
constants like:
(const_poly_int [(const_int c0)
(const_int c1)
...
(const_int cn)])
although the coefficients could be const_wide_ints instead
of const_ints where appropriate.
(3) Add a new rtl code for the polynomial indeterminates,
then use them in const wrappers. A constant like c0 + c1 * x1
would then look like:
(const:M (plus:M (mult:M (const_param:M x1)
(const_int c1))
(const_int c0)))
There didn't seem to be that much to choose between them. The main
advantage of (1) is that it's a more efficient representation and
that we can refer to the cofficients directly as wide_int_storage.
2017-12-20 Richard Sandiford <richard.sandiford@linaro.org>
Alan Hayward <alan.hayward@arm.com>
David Sherwood <david.sherwood@arm.com>
gcc/
* doc/rtl.texi (const_poly_int): Document. Also document the
rtl sharing behavior.
* gengenrtl.c (excluded_rtx): Return true for CONST_POLY_INT.
* rtl.h (const_poly_int_def): New struct.
(rtx_def::u): Add a cpi field.
(CASE_CONST_UNIQUE, CASE_CONST_ANY): Add CONST_POLY_INT.
(CONST_POLY_INT_P, CONST_POLY_INT_COEFFS): New macros.
(wi::rtx_to_poly_wide_ref): New typedef
(const_poly_int_value, wi::to_poly_wide, rtx_to_poly_int64)
(poly_int_rtx_p): New functions.
(trunc_int_for_mode): Declare a poly_int64 version.
(plus_constant): Take a poly_int64 instead of a HOST_WIDE_INT.
(immed_wide_int_const): Take a poly_wide_int_ref rather than
a wide_int_ref.
(strip_offset): Declare.
(strip_offset_and_add): New function.
* rtl.def (CONST_POLY_INT): New rtx code.
* rtl.c (rtx_size): Handle CONST_POLY_INT.
(shared_const_p): Use poly_int_rtx_p.
* emit-rtl.h (gen_int_mode): Take a poly_int64 instead of a
HOST_WIDE_INT.
(gen_int_shift_amount): Likewise.
* emit-rtl.c (const_poly_int_hasher): New class.
(const_poly_int_htab): New variable.
(init_emit_once): Initialize it when NUM_POLY_INT_COEFFS > 1.
(const_poly_int_hasher::hash): New function.
(const_poly_int_hasher::equal): Likewise.
(gen_int_mode): Take a poly_int64 instead of a HOST_WIDE_INT.
(immed_wide_int_const): Rename to...
(immed_wide_int_const_1): ...this and make static.
(immed_wide_int_const): New function, taking a poly_wide_int_ref
instead of a wide_int_ref.
(gen_int_shift_amount): Take a poly_int64 instead of a HOST_WIDE_INT.
(gen_lowpart_common): Handle CONST_POLY_INT.
* cse.c (hash_rtx_cb, equiv_constant): Likewise.
* cselib.c (cselib_hash_rtx): Likewise.
* dwarf2out.c (const_ok_for_output_1): Likewise.
* expr.c (convert_modes): Likewise.
* print-rtl.c (rtx_writer::print_rtx, print_value): Likewise.
* rtlhash.c (add_rtx): Likewise.
* explow.c (trunc_int_for_mode): Add a poly_int64 version.
(plus_constant): Take a poly_int64 instead of a HOST_WIDE_INT.
Handle existing CONST_POLY_INT rtxes.
* expmed.h (expand_shift): Take a poly_int64 instead of a
HOST_WIDE_INT.
* expmed.c (expand_shift): Likewise.
* rtlanal.c (strip_offset): New function.
(commutative_operand_precedence): Give CONST_POLY_INT the same
precedence as CONST_DOUBLE and put CONST_WIDE_INT between that
and CONST_INT.
* rtl-tests.c (const_poly_int_tests): New struct.
(rtl_tests_c_tests): Use it.
* simplify-rtx.c (simplify_const_unary_operation): Handle
CONST_POLY_INT.
(simplify_const_binary_operation): Likewise.
(simplify_binary_operation_1): Fold additions of symbolic constants
and CONST_POLY_INTs.
(simplify_subreg): Handle extensions and truncations of
CONST_POLY_INTs.
(simplify_const_poly_int_tests): New struct.
(simplify_rtx_c_tests): Use it.
* wide-int.h (storage_ref): Add default constructor.
(wide_int_ref_storage): Likewise.
(trailing_wide_ints): Use GTY((user)).
(trailing_wide_ints::operator[]): Add a const version.
(trailing_wide_ints::get_precision): New function.
(trailing_wide_ints::extra_size): Likewise.
Co-Authored-By: Alan Hayward <alan.hayward@arm.com>
Co-Authored-By: David Sherwood <david.sherwood@arm.com>
From-SVN: r255862
This commit is contained in:
Richard Sandiford
Richard Sandiford
parent
abd3c80010
commit
0c12fc9b2d
21 changed files with 638 additions and 34 deletions
|
|
@ -1,3 +1,75 @@
|
|||
2017-12-20 Richard Sandiford <richard.sandiford@linaro.org>
|
||||
Alan Hayward <alan.hayward@arm.com>
|
||||
David Sherwood <david.sherwood@arm.com>
|
||||
|
||||
* doc/rtl.texi (const_poly_int): Document. Also document the
|
||||
rtl sharing behavior.
|
||||
* gengenrtl.c (excluded_rtx): Return true for CONST_POLY_INT.
|
||||
* rtl.h (const_poly_int_def): New struct.
|
||||
(rtx_def::u): Add a cpi field.
|
||||
(CASE_CONST_UNIQUE, CASE_CONST_ANY): Add CONST_POLY_INT.
|
||||
(CONST_POLY_INT_P, CONST_POLY_INT_COEFFS): New macros.
|
||||
(wi::rtx_to_poly_wide_ref): New typedef
|
||||
(const_poly_int_value, wi::to_poly_wide, rtx_to_poly_int64)
|
||||
(poly_int_rtx_p): New functions.
|
||||
(trunc_int_for_mode): Declare a poly_int64 version.
|
||||
(plus_constant): Take a poly_int64 instead of a HOST_WIDE_INT.
|
||||
(immed_wide_int_const): Take a poly_wide_int_ref rather than
|
||||
a wide_int_ref.
|
||||
(strip_offset): Declare.
|
||||
(strip_offset_and_add): New function.
|
||||
* rtl.def (CONST_POLY_INT): New rtx code.
|
||||
* rtl.c (rtx_size): Handle CONST_POLY_INT.
|
||||
(shared_const_p): Use poly_int_rtx_p.
|
||||
* emit-rtl.h (gen_int_mode): Take a poly_int64 instead of a
|
||||
HOST_WIDE_INT.
|
||||
(gen_int_shift_amount): Likewise.
|
||||
* emit-rtl.c (const_poly_int_hasher): New class.
|
||||
(const_poly_int_htab): New variable.
|
||||
(init_emit_once): Initialize it when NUM_POLY_INT_COEFFS > 1.
|
||||
(const_poly_int_hasher::hash): New function.
|
||||
(const_poly_int_hasher::equal): Likewise.
|
||||
(gen_int_mode): Take a poly_int64 instead of a HOST_WIDE_INT.
|
||||
(immed_wide_int_const): Rename to...
|
||||
(immed_wide_int_const_1): ...this and make static.
|
||||
(immed_wide_int_const): New function, taking a poly_wide_int_ref
|
||||
instead of a wide_int_ref.
|
||||
(gen_int_shift_amount): Take a poly_int64 instead of a HOST_WIDE_INT.
|
||||
(gen_lowpart_common): Handle CONST_POLY_INT.
|
||||
* cse.c (hash_rtx_cb, equiv_constant): Likewise.
|
||||
* cselib.c (cselib_hash_rtx): Likewise.
|
||||
* dwarf2out.c (const_ok_for_output_1): Likewise.
|
||||
* expr.c (convert_modes): Likewise.
|
||||
* print-rtl.c (rtx_writer::print_rtx, print_value): Likewise.
|
||||
* rtlhash.c (add_rtx): Likewise.
|
||||
* explow.c (trunc_int_for_mode): Add a poly_int64 version.
|
||||
(plus_constant): Take a poly_int64 instead of a HOST_WIDE_INT.
|
||||
Handle existing CONST_POLY_INT rtxes.
|
||||
* expmed.h (expand_shift): Take a poly_int64 instead of a
|
||||
HOST_WIDE_INT.
|
||||
* expmed.c (expand_shift): Likewise.
|
||||
* rtlanal.c (strip_offset): New function.
|
||||
(commutative_operand_precedence): Give CONST_POLY_INT the same
|
||||
precedence as CONST_DOUBLE and put CONST_WIDE_INT between that
|
||||
and CONST_INT.
|
||||
* rtl-tests.c (const_poly_int_tests): New struct.
|
||||
(rtl_tests_c_tests): Use it.
|
||||
* simplify-rtx.c (simplify_const_unary_operation): Handle
|
||||
CONST_POLY_INT.
|
||||
(simplify_const_binary_operation): Likewise.
|
||||
(simplify_binary_operation_1): Fold additions of symbolic constants
|
||||
and CONST_POLY_INTs.
|
||||
(simplify_subreg): Handle extensions and truncations of
|
||||
CONST_POLY_INTs.
|
||||
(simplify_const_poly_int_tests): New struct.
|
||||
(simplify_rtx_c_tests): Use it.
|
||||
* wide-int.h (storage_ref): Add default constructor.
|
||||
(wide_int_ref_storage): Likewise.
|
||||
(trailing_wide_ints): Use GTY((user)).
|
||||
(trailing_wide_ints::operator[]): Add a const version.
|
||||
(trailing_wide_ints::get_precision): New function.
|
||||
(trailing_wide_ints::extra_size): Likewise.
|
||||
|
||||
2017-12-20 Richard Sandiford <richard.sandiford@linaro.org>
|
||||
Alan Hayward <alan.hayward@arm.com>
|
||||
David Sherwood <david.sherwood@arm.com>
|
||||
|
|
|
|||
11
gcc/cse.c
11
gcc/cse.c
|
|
@ -2323,6 +2323,15 @@ hash_rtx_cb (const_rtx x, machine_mode mode,
|
|||
hash += CONST_WIDE_INT_ELT (x, i);
|
||||
return hash;
|
||||
|
||||
case CONST_POLY_INT:
|
||||
{
|
||||
inchash::hash h;
|
||||
h.add_int (hash);
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
h.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
|
||||
return h.end ();
|
||||
}
|
||||
|
||||
case CONST_DOUBLE:
|
||||
/* This is like the general case, except that it only counts
|
||||
the integers representing the constant. */
|
||||
|
|
@ -3781,6 +3790,8 @@ equiv_constant (rtx x)
|
|||
/* See if we previously assigned a constant value to this SUBREG. */
|
||||
if ((new_rtx = lookup_as_function (x, CONST_INT)) != 0
|
||||
|| (new_rtx = lookup_as_function (x, CONST_WIDE_INT)) != 0
|
||||
|| (NUM_POLY_INT_COEFFS > 1
|
||||
&& (new_rtx = lookup_as_function (x, CONST_POLY_INT)) != 0)
|
||||
|| (new_rtx = lookup_as_function (x, CONST_DOUBLE)) != 0
|
||||
|| (new_rtx = lookup_as_function (x, CONST_FIXED)) != 0)
|
||||
return new_rtx;
|
||||
|
|
|
|||
|
|
@ -1128,6 +1128,15 @@ cselib_hash_rtx (rtx x, int create, machine_mode memmode)
|
|||
hash += CONST_WIDE_INT_ELT (x, i);
|
||||
return hash;
|
||||
|
||||
case CONST_POLY_INT:
|
||||
{
|
||||
inchash::hash h;
|
||||
h.add_int (hash);
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
h.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
|
||||
return h.end ();
|
||||
}
|
||||
|
||||
case CONST_DOUBLE:
|
||||
/* This is like the general case, except that it only counts
|
||||
the integers representing the constant. */
|
||||
|
|
|
|||
|
|
@ -1633,6 +1633,15 @@ is accessed with the macro @code{CONST_FIXED_VALUE}. The high part of
|
|||
data is accessed with @code{CONST_FIXED_VALUE_HIGH}; the low part is
|
||||
accessed with @code{CONST_FIXED_VALUE_LOW}.
|
||||
|
||||
@findex const_poly_int
|
||||
@item (const_poly_int:@var{m} [@var{c0} @var{c1} @dots{}])
|
||||
Represents a @code{poly_int}-style polynomial integer with coefficients
|
||||
@var{c0}, @var{c1}, @dots{}. The coefficients are @code{wide_int}-based
|
||||
integers rather than rtxes. @code{CONST_POLY_INT_COEFFS} gives the
|
||||
values of individual coefficients (which is mostly only useful in
|
||||
low-level routines) and @code{const_poly_int_value} gives the full
|
||||
@code{poly_int} value.
|
||||
|
||||
@findex const_vector
|
||||
@item (const_vector:@var{m} [@var{x0} @var{x1} @dots{}])
|
||||
Represents a vector constant. The square brackets stand for the vector
|
||||
|
|
@ -4236,6 +4245,11 @@ referring to it.
|
|||
@item
|
||||
All @code{const_int} expressions with equal values are shared.
|
||||
|
||||
@cindex @code{const_poly_int}, RTL sharing
|
||||
@item
|
||||
All @code{const_poly_int} expressions with equal modes and values
|
||||
are shared.
|
||||
|
||||
@cindex @code{pc}, RTL sharing
|
||||
@item
|
||||
There is only one @code{pc} expression.
|
||||
|
|
|
|||
|
|
@ -13781,6 +13781,16 @@ const_ok_for_output_1 (rtx rtl)
|
|||
return false;
|
||||
}
|
||||
|
||||
if (CONST_POLY_INT_P (rtl))
|
||||
return false;
|
||||
|
||||
if (targetm.const_not_ok_for_debug_p (rtl))
|
||||
{
|
||||
expansion_failed (NULL_TREE, rtl,
|
||||
"Expression rejected for debug by the backend.\n");
|
||||
return false;
|
||||
}
|
||||
|
||||
/* FIXME: Refer to PR60655. It is possible for simplification
|
||||
of rtl expressions in var tracking to produce such expressions.
|
||||
We should really identify / validate expressions
|
||||
|
|
|
|||
102
gcc/emit-rtl.c
102
gcc/emit-rtl.c
|
|
@ -148,6 +148,16 @@ struct const_wide_int_hasher : ggc_cache_ptr_hash<rtx_def>
|
|||
|
||||
static GTY ((cache)) hash_table<const_wide_int_hasher> *const_wide_int_htab;
|
||||
|
||||
struct const_poly_int_hasher : ggc_cache_ptr_hash<rtx_def>
|
||||
{
|
||||
typedef std::pair<machine_mode, poly_wide_int_ref> compare_type;
|
||||
|
||||
static hashval_t hash (rtx x);
|
||||
static bool equal (rtx x, const compare_type &y);
|
||||
};
|
||||
|
||||
static GTY ((cache)) hash_table<const_poly_int_hasher> *const_poly_int_htab;
|
||||
|
||||
/* A hash table storing register attribute structures. */
|
||||
struct reg_attr_hasher : ggc_cache_ptr_hash<reg_attrs>
|
||||
{
|
||||
|
|
@ -248,6 +258,31 @@ const_wide_int_hasher::equal (rtx x, rtx y)
|
|||
}
|
||||
#endif
|
||||
|
||||
/* Returns a hash code for CONST_POLY_INT X. */
|
||||
|
||||
hashval_t
|
||||
const_poly_int_hasher::hash (rtx x)
|
||||
{
|
||||
inchash::hash h;
|
||||
h.add_int (GET_MODE (x));
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
h.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
|
||||
return h.end ();
|
||||
}
|
||||
|
||||
/* Returns nonzero if CONST_POLY_INT X is an rtx representation of Y. */
|
||||
|
||||
bool
|
||||
const_poly_int_hasher::equal (rtx x, const compare_type &y)
|
||||
{
|
||||
if (GET_MODE (x) != y.first)
|
||||
return false;
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
if (CONST_POLY_INT_COEFFS (x)[i] != y.second.coeffs[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Returns a hash code for X (which is really a CONST_DOUBLE). */
|
||||
hashval_t
|
||||
const_double_hasher::hash (rtx x)
|
||||
|
|
@ -489,9 +524,13 @@ gen_rtx_CONST_INT (machine_mode mode ATTRIBUTE_UNUSED, HOST_WIDE_INT arg)
|
|||
}
|
||||
|
||||
rtx
|
||||
gen_int_mode (HOST_WIDE_INT c, machine_mode mode)
|
||||
gen_int_mode (poly_int64 c, machine_mode mode)
|
||||
{
|
||||
return GEN_INT (trunc_int_for_mode (c, mode));
|
||||
c = trunc_int_for_mode (c, mode);
|
||||
if (c.is_constant ())
|
||||
return GEN_INT (c.coeffs[0]);
|
||||
unsigned int prec = GET_MODE_PRECISION (as_a <scalar_mode> (mode));
|
||||
return immed_wide_int_const (poly_wide_int::from (c, prec, SIGNED), mode);
|
||||
}
|
||||
|
||||
/* CONST_DOUBLEs might be created from pairs of integers, or from
|
||||
|
|
@ -595,8 +634,8 @@ lookup_const_wide_int (rtx wint)
|
|||
a CONST_DOUBLE (if !TARGET_SUPPORTS_WIDE_INT) or a CONST_WIDE_INT
|
||||
(if TARGET_SUPPORTS_WIDE_INT). */
|
||||
|
||||
rtx
|
||||
immed_wide_int_const (const wide_int_ref &v, machine_mode mode)
|
||||
static rtx
|
||||
immed_wide_int_const_1 (const wide_int_ref &v, machine_mode mode)
|
||||
{
|
||||
unsigned int len = v.get_len ();
|
||||
/* Not scalar_int_mode because we also allow pointer bound modes. */
|
||||
|
|
@ -683,6 +722,53 @@ immed_double_const (HOST_WIDE_INT i0, HOST_WIDE_INT i1, machine_mode mode)
|
|||
}
|
||||
#endif
|
||||
|
||||
/* Return an rtx representation of C in mode MODE. */
|
||||
|
||||
rtx
|
||||
immed_wide_int_const (const poly_wide_int_ref &c, machine_mode mode)
|
||||
{
|
||||
if (c.is_constant ())
|
||||
return immed_wide_int_const_1 (c.coeffs[0], mode);
|
||||
|
||||
/* Not scalar_int_mode because we also allow pointer bound modes. */
|
||||
unsigned int prec = GET_MODE_PRECISION (as_a <scalar_mode> (mode));
|
||||
|
||||
/* Allow truncation but not extension since we do not know if the
|
||||
number is signed or unsigned. */
|
||||
gcc_assert (prec <= c.coeffs[0].get_precision ());
|
||||
poly_wide_int newc = poly_wide_int::from (c, prec, SIGNED);
|
||||
|
||||
/* See whether we already have an rtx for this constant. */
|
||||
inchash::hash h;
|
||||
h.add_int (mode);
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
h.add_wide_int (newc.coeffs[i]);
|
||||
const_poly_int_hasher::compare_type typed_value (mode, newc);
|
||||
rtx *slot = const_poly_int_htab->find_slot_with_hash (typed_value,
|
||||
h.end (), INSERT);
|
||||
rtx x = *slot;
|
||||
if (x)
|
||||
return x;
|
||||
|
||||
/* Create a new rtx. There's a choice to be made here between installing
|
||||
the actual mode of the rtx or leaving it as VOIDmode (for consistency
|
||||
with CONST_INT). In practice the handling of the codes is different
|
||||
enough that we get no benefit from using VOIDmode, and various places
|
||||
assume that VOIDmode implies CONST_INT. Using the real mode seems like
|
||||
the right long-term direction anyway. */
|
||||
typedef trailing_wide_ints<NUM_POLY_INT_COEFFS> twi;
|
||||
size_t extra_size = twi::extra_size (prec);
|
||||
x = rtx_alloc_v (CONST_POLY_INT,
|
||||
sizeof (struct const_poly_int_def) + extra_size);
|
||||
PUT_MODE (x, mode);
|
||||
CONST_POLY_INT_COEFFS (x).set_precision (prec);
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
CONST_POLY_INT_COEFFS (x)[i] = newc.coeffs[i];
|
||||
|
||||
*slot = x;
|
||||
return x;
|
||||
}
|
||||
|
||||
rtx
|
||||
gen_rtx_REG (machine_mode mode, unsigned int regno)
|
||||
{
|
||||
|
|
@ -1486,7 +1572,8 @@ gen_lowpart_common (machine_mode mode, rtx x)
|
|||
}
|
||||
else if (GET_CODE (x) == SUBREG || REG_P (x)
|
||||
|| GET_CODE (x) == CONCAT || const_vec_p (x)
|
||||
|| CONST_DOUBLE_AS_FLOAT_P (x) || CONST_SCALAR_INT_P (x))
|
||||
|| CONST_DOUBLE_AS_FLOAT_P (x) || CONST_SCALAR_INT_P (x)
|
||||
|| CONST_POLY_INT_P (x))
|
||||
return lowpart_subreg (mode, x, innermode);
|
||||
|
||||
/* Otherwise, we can't do this. */
|
||||
|
|
@ -6031,6 +6118,9 @@ init_emit_once (void)
|
|||
#endif
|
||||
const_double_htab = hash_table<const_double_hasher>::create_ggc (37);
|
||||
|
||||
if (NUM_POLY_INT_COEFFS > 1)
|
||||
const_poly_int_htab = hash_table<const_poly_int_hasher>::create_ggc (37);
|
||||
|
||||
const_fixed_htab = hash_table<const_fixed_hasher>::create_ggc (37);
|
||||
|
||||
reg_attrs_htab = hash_table<reg_attr_hasher>::create_ggc (37);
|
||||
|
|
@ -6422,7 +6512,7 @@ need_atomic_barrier_p (enum memmodel model, bool pre)
|
|||
by VALUE bits. */
|
||||
|
||||
rtx
|
||||
gen_int_shift_amount (machine_mode, HOST_WIDE_INT value)
|
||||
gen_int_shift_amount (machine_mode, poly_int64 value)
|
||||
{
|
||||
/* Use a 64-bit mode, to avoid any truncation.
|
||||
|
||||
|
|
|
|||
|
|
@ -362,14 +362,14 @@ extern rtvec gen_rtvec (int, ...);
|
|||
extern rtx copy_insn_1 (rtx);
|
||||
extern rtx copy_insn (rtx);
|
||||
extern rtx_insn *copy_delay_slot_insn (rtx_insn *);
|
||||
extern rtx gen_int_mode (HOST_WIDE_INT, machine_mode);
|
||||
extern rtx gen_int_mode (poly_int64, machine_mode);
|
||||
extern rtx_insn *emit_copy_of_insn_after (rtx_insn *, rtx_insn *);
|
||||
extern void set_reg_attrs_from_value (rtx, rtx);
|
||||
extern void set_reg_attrs_for_parm (rtx, rtx);
|
||||
extern void set_reg_attrs_for_decl_rtl (tree t, rtx x);
|
||||
extern void adjust_reg_mode (rtx, machine_mode);
|
||||
extern int mem_expr_equal_p (const_tree, const_tree);
|
||||
extern rtx gen_int_shift_amount (machine_mode, HOST_WIDE_INT);
|
||||
extern rtx gen_int_shift_amount (machine_mode, poly_int64);
|
||||
|
||||
extern bool need_atomic_barrier_p (enum memmodel, bool);
|
||||
|
||||
|
|
|
|||
20
gcc/explow.c
20
gcc/explow.c
|
|
@ -77,13 +77,23 @@ trunc_int_for_mode (HOST_WIDE_INT c, machine_mode mode)
|
|||
return c;
|
||||
}
|
||||
|
||||
/* Likewise for polynomial values, using the sign-extended representation
|
||||
for each individual coefficient. */
|
||||
|
||||
poly_int64
|
||||
trunc_int_for_mode (poly_int64 x, machine_mode mode)
|
||||
{
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
x.coeffs[i] = trunc_int_for_mode (x.coeffs[i], mode);
|
||||
return x;
|
||||
}
|
||||
|
||||
/* Return an rtx for the sum of X and the integer C, given that X has
|
||||
mode MODE. INPLACE is true if X can be modified inplace or false
|
||||
if it must be treated as immutable. */
|
||||
|
||||
rtx
|
||||
plus_constant (machine_mode mode, rtx x, HOST_WIDE_INT c,
|
||||
bool inplace)
|
||||
plus_constant (machine_mode mode, rtx x, poly_int64 c, bool inplace)
|
||||
{
|
||||
RTX_CODE code;
|
||||
rtx y;
|
||||
|
|
@ -92,7 +102,7 @@ plus_constant (machine_mode mode, rtx x, HOST_WIDE_INT c,
|
|||
|
||||
gcc_assert (GET_MODE (x) == VOIDmode || GET_MODE (x) == mode);
|
||||
|
||||
if (c == 0)
|
||||
if (known_eq (c, 0))
|
||||
return x;
|
||||
|
||||
restart:
|
||||
|
|
@ -180,10 +190,12 @@ plus_constant (machine_mode mode, rtx x, HOST_WIDE_INT c,
|
|||
break;
|
||||
|
||||
default:
|
||||
if (CONST_POLY_INT_P (x))
|
||||
return immed_wide_int_const (const_poly_int_value (x) + c, mode);
|
||||
break;
|
||||
}
|
||||
|
||||
if (c != 0)
|
||||
if (maybe_ne (c, 0))
|
||||
x = gen_rtx_PLUS (mode, x, gen_int_mode (c, mode));
|
||||
|
||||
if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
|
||||
|
|
|
|||
|
|
@ -2541,7 +2541,7 @@ expand_shift_1 (enum tree_code code, machine_mode mode, rtx shifted,
|
|||
|
||||
rtx
|
||||
expand_shift (enum tree_code code, machine_mode mode, rtx shifted,
|
||||
int amount, rtx target, int unsignedp)
|
||||
poly_int64 amount, rtx target, int unsignedp)
|
||||
{
|
||||
return expand_shift_1 (code, mode, shifted,
|
||||
gen_int_shift_amount (mode, amount),
|
||||
|
|
|
|||
|
|
@ -712,8 +712,8 @@ extern unsigned HOST_WIDE_INT choose_multiplier (unsigned HOST_WIDE_INT, int,
|
|||
#ifdef TREE_CODE
|
||||
extern rtx expand_variable_shift (enum tree_code, machine_mode,
|
||||
rtx, tree, rtx, int);
|
||||
extern rtx expand_shift (enum tree_code, machine_mode, rtx, int, rtx,
|
||||
int);
|
||||
extern rtx expand_shift (enum tree_code, machine_mode, rtx, poly_int64, rtx,
|
||||
int);
|
||||
extern rtx expand_divmod (int, enum tree_code, machine_mode, rtx, rtx,
|
||||
rtx, int);
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -692,6 +692,7 @@ convert_modes (machine_mode mode, machine_mode oldmode, rtx x, int unsignedp)
|
|||
&& is_int_mode (oldmode, &int_oldmode)
|
||||
&& GET_MODE_PRECISION (int_mode) <= GET_MODE_PRECISION (int_oldmode)
|
||||
&& ((MEM_P (x) && !MEM_VOLATILE_P (x) && direct_load[(int) int_mode])
|
||||
|| CONST_POLY_INT_P (x)
|
||||
|| (REG_P (x)
|
||||
&& (!HARD_REGISTER_P (x)
|
||||
|| targetm.hard_regno_mode_ok (REGNO (x), int_mode))
|
||||
|
|
|
|||
|
|
@ -156,6 +156,7 @@ excluded_rtx (int idx)
|
|||
return (strcmp (defs[idx].enumname, "VAR_LOCATION") == 0
|
||||
|| strcmp (defs[idx].enumname, "CONST_DOUBLE") == 0
|
||||
|| strcmp (defs[idx].enumname, "CONST_WIDE_INT") == 0
|
||||
|| strcmp (defs[idx].enumname, "CONST_POLY_INT") == 0
|
||||
|| strcmp (defs[idx].enumname, "CONST_FIXED") == 0);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -908,6 +908,17 @@ rtx_writer::print_rtx (const_rtx in_rtx)
|
|||
fprintf (m_outfile, " ");
|
||||
cwi_output_hex (m_outfile, in_rtx);
|
||||
break;
|
||||
|
||||
case CONST_POLY_INT:
|
||||
fprintf (m_outfile, " [");
|
||||
print_dec (CONST_POLY_INT_COEFFS (in_rtx)[0], m_outfile, SIGNED);
|
||||
for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
{
|
||||
fprintf (m_outfile, ", ");
|
||||
print_dec (CONST_POLY_INT_COEFFS (in_rtx)[i], m_outfile, SIGNED);
|
||||
}
|
||||
fprintf (m_outfile, "]");
|
||||
break;
|
||||
#endif
|
||||
|
||||
case CODE_LABEL:
|
||||
|
|
@ -1595,6 +1606,17 @@ print_value (pretty_printer *pp, const_rtx x, int verbose)
|
|||
}
|
||||
break;
|
||||
|
||||
case CONST_POLY_INT:
|
||||
pp_left_bracket (pp);
|
||||
pp_wide_int (pp, CONST_POLY_INT_COEFFS (x)[0], SIGNED);
|
||||
for (unsigned int i = 1; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
{
|
||||
pp_string (pp, ", ");
|
||||
pp_wide_int (pp, CONST_POLY_INT_COEFFS (x)[i], SIGNED);
|
||||
}
|
||||
pp_right_bracket (pp);
|
||||
break;
|
||||
|
||||
case CONST_DOUBLE:
|
||||
if (FLOAT_MODE_P (GET_MODE (x)))
|
||||
{
|
||||
|
|
|
|||
|
|
@ -228,6 +228,62 @@ test_uncond_jump ()
|
|||
jump_insn);
|
||||
}
|
||||
|
||||
template<unsigned int N>
|
||||
struct const_poly_int_tests
|
||||
{
|
||||
static void run ();
|
||||
};
|
||||
|
||||
template<>
|
||||
struct const_poly_int_tests<1>
|
||||
{
|
||||
static void run () {}
|
||||
};
|
||||
|
||||
/* Test various CONST_POLY_INT properties. */
|
||||
|
||||
template<unsigned int N>
|
||||
void
|
||||
const_poly_int_tests<N>::run ()
|
||||
{
|
||||
rtx x1 = gen_int_mode (poly_int64 (1, 1), QImode);
|
||||
rtx x255 = gen_int_mode (poly_int64 (1, 255), QImode);
|
||||
|
||||
/* Test that constants are unique. */
|
||||
ASSERT_EQ (x1, gen_int_mode (poly_int64 (1, 1), QImode));
|
||||
ASSERT_NE (x1, gen_int_mode (poly_int64 (1, 1), HImode));
|
||||
ASSERT_NE (x1, x255);
|
||||
|
||||
/* Test const_poly_int_value. */
|
||||
ASSERT_KNOWN_EQ (const_poly_int_value (x1), poly_int64 (1, 1));
|
||||
ASSERT_KNOWN_EQ (const_poly_int_value (x255), poly_int64 (1, -1));
|
||||
|
||||
/* Test rtx_to_poly_int64. */
|
||||
ASSERT_KNOWN_EQ (rtx_to_poly_int64 (x1), poly_int64 (1, 1));
|
||||
ASSERT_KNOWN_EQ (rtx_to_poly_int64 (x255), poly_int64 (1, -1));
|
||||
ASSERT_MAYBE_NE (rtx_to_poly_int64 (x255), poly_int64 (1, 255));
|
||||
|
||||
/* Test plus_constant of a symbol. */
|
||||
rtx symbol = gen_rtx_SYMBOL_REF (Pmode, "foo");
|
||||
rtx offset1 = gen_int_mode (poly_int64 (9, 11), Pmode);
|
||||
rtx sum1 = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, symbol, offset1));
|
||||
ASSERT_RTX_EQ (plus_constant (Pmode, symbol, poly_int64 (9, 11)), sum1);
|
||||
|
||||
/* Test plus_constant of a CONST. */
|
||||
rtx offset2 = gen_int_mode (poly_int64 (12, 20), Pmode);
|
||||
rtx sum2 = gen_rtx_CONST (Pmode, gen_rtx_PLUS (Pmode, symbol, offset2));
|
||||
ASSERT_RTX_EQ (plus_constant (Pmode, sum1, poly_int64 (3, 9)), sum2);
|
||||
|
||||
/* Test a cancelling plus_constant. */
|
||||
ASSERT_EQ (plus_constant (Pmode, sum2, poly_int64 (-12, -20)), symbol);
|
||||
|
||||
/* Test plus_constant on integer constants. */
|
||||
ASSERT_EQ (plus_constant (QImode, const1_rtx, poly_int64 (4, -2)),
|
||||
gen_int_mode (poly_int64 (5, -2), QImode));
|
||||
ASSERT_EQ (plus_constant (QImode, x1, poly_int64 (4, -2)),
|
||||
gen_int_mode (poly_int64 (5, -1), QImode));
|
||||
}
|
||||
|
||||
/* Run all of the selftests within this file. */
|
||||
|
||||
void
|
||||
|
|
@ -238,6 +294,7 @@ rtl_tests_c_tests ()
|
|||
test_dumping_rtx_reuse ();
|
||||
test_single_set ();
|
||||
test_uncond_jump ();
|
||||
const_poly_int_tests<NUM_POLY_INT_COEFFS>::run ();
|
||||
|
||||
/* Purge state. */
|
||||
set_first_insn (NULL);
|
||||
|
|
|
|||
|
|
@ -189,6 +189,10 @@ rtx_size (const_rtx x)
|
|||
+ sizeof (struct hwivec_def)
|
||||
+ ((CONST_WIDE_INT_NUNITS (x) - 1)
|
||||
* sizeof (HOST_WIDE_INT)));
|
||||
if (CONST_POLY_INT_P (x))
|
||||
return (RTX_HDR_SIZE
|
||||
+ sizeof (struct const_poly_int_def)
|
||||
+ CONST_POLY_INT_COEFFS (x).extra_size ());
|
||||
if (GET_CODE (x) == SYMBOL_REF && SYMBOL_REF_HAS_BLOCK_INFO_P (x))
|
||||
return RTX_HDR_SIZE + sizeof (struct block_symbol);
|
||||
return RTX_CODE_SIZE (GET_CODE (x));
|
||||
|
|
@ -254,9 +258,10 @@ shared_const_p (const_rtx orig)
|
|||
|
||||
/* CONST can be shared if it contains a SYMBOL_REF. If it contains
|
||||
a LABEL_REF, it isn't sharable. */
|
||||
poly_int64 offset;
|
||||
return (GET_CODE (XEXP (orig, 0)) == PLUS
|
||||
&& GET_CODE (XEXP (XEXP (orig, 0), 0)) == SYMBOL_REF
|
||||
&& CONST_INT_P (XEXP (XEXP (orig, 0), 1)));
|
||||
&& poly_int_rtx_p (XEXP (XEXP (orig, 0), 1), &offset));
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -348,6 +348,9 @@ DEF_RTL_EXPR(CONST_INT, "const_int", "w", RTX_CONST_OBJ)
|
|||
/* numeric integer constant */
|
||||
DEF_RTL_EXPR(CONST_WIDE_INT, "const_wide_int", "", RTX_CONST_OBJ)
|
||||
|
||||
/* An rtx representation of a poly_wide_int. */
|
||||
DEF_RTL_EXPR(CONST_POLY_INT, "const_poly_int", "", RTX_CONST_OBJ)
|
||||
|
||||
/* fixed-point constant */
|
||||
DEF_RTL_EXPR(CONST_FIXED, "const_fixed", "www", RTX_CONST_OBJ)
|
||||
|
||||
|
|
|
|||
119
gcc/rtl.h
119
gcc/rtl.h
|
|
@ -280,6 +280,10 @@ struct GTY((variable_size)) hwivec_def {
|
|||
#define CWI_PUT_NUM_ELEM(RTX, NUM) \
|
||||
(RTL_FLAG_CHECK1("CWI_PUT_NUM_ELEM", (RTX), CONST_WIDE_INT)->u2.num_elem = (NUM))
|
||||
|
||||
struct GTY((variable_size)) const_poly_int_def {
|
||||
trailing_wide_ints<NUM_POLY_INT_COEFFS> coeffs;
|
||||
};
|
||||
|
||||
/* RTL expression ("rtx"). */
|
||||
|
||||
/* The GTY "desc" and "tag" options below are a kludge: we need a desc
|
||||
|
|
@ -424,6 +428,7 @@ struct GTY((desc("0"), tag("0"),
|
|||
struct real_value rv;
|
||||
struct fixed_value fv;
|
||||
struct hwivec_def hwiv;
|
||||
struct const_poly_int_def cpi;
|
||||
} GTY ((special ("rtx_def"), desc ("GET_CODE (&%0)"))) u;
|
||||
};
|
||||
|
||||
|
|
@ -734,6 +739,7 @@ struct GTY(()) rtvec_def {
|
|||
#define CASE_CONST_UNIQUE \
|
||||
case CONST_INT: \
|
||||
case CONST_WIDE_INT: \
|
||||
case CONST_POLY_INT: \
|
||||
case CONST_DOUBLE: \
|
||||
case CONST_FIXED
|
||||
|
||||
|
|
@ -741,6 +747,7 @@ struct GTY(()) rtvec_def {
|
|||
#define CASE_CONST_ANY \
|
||||
case CONST_INT: \
|
||||
case CONST_WIDE_INT: \
|
||||
case CONST_POLY_INT: \
|
||||
case CONST_DOUBLE: \
|
||||
case CONST_FIXED: \
|
||||
case CONST_VECTOR
|
||||
|
|
@ -773,6 +780,11 @@ struct GTY(()) rtvec_def {
|
|||
/* Predicate yielding nonzero iff X is an rtx for a constant integer. */
|
||||
#define CONST_WIDE_INT_P(X) (GET_CODE (X) == CONST_WIDE_INT)
|
||||
|
||||
/* Predicate yielding nonzero iff X is an rtx for a polynomial constant
|
||||
integer. */
|
||||
#define CONST_POLY_INT_P(X) \
|
||||
(NUM_POLY_INT_COEFFS > 1 && GET_CODE (X) == CONST_POLY_INT)
|
||||
|
||||
/* Predicate yielding nonzero iff X is an rtx for a constant fixed-point. */
|
||||
#define CONST_FIXED_P(X) (GET_CODE (X) == CONST_FIXED)
|
||||
|
||||
|
|
@ -1914,6 +1926,12 @@ set_regno_raw (rtx x, unsigned int regno, unsigned int nregs)
|
|||
#define CONST_WIDE_INT_NUNITS(RTX) CWI_GET_NUM_ELEM (RTX)
|
||||
#define CONST_WIDE_INT_ELT(RTX, N) CWI_ELT (RTX, N)
|
||||
|
||||
/* For a CONST_POLY_INT, CONST_POLY_INT_COEFFS gives access to the
|
||||
individual coefficients, in the form of a trailing_wide_ints structure. */
|
||||
#define CONST_POLY_INT_COEFFS(RTX) \
|
||||
(RTL_FLAG_CHECK1("CONST_POLY_INT_COEFFS", (RTX), \
|
||||
CONST_POLY_INT)->u.cpi.coeffs)
|
||||
|
||||
/* For a CONST_DOUBLE:
|
||||
#if TARGET_SUPPORTS_WIDE_INT == 0
|
||||
For a VOIDmode, there are two integers CONST_DOUBLE_LOW is the
|
||||
|
|
@ -2227,6 +2245,84 @@ wi::max_value (machine_mode mode, signop sgn)
|
|||
return max_value (GET_MODE_PRECISION (as_a <scalar_mode> (mode)), sgn);
|
||||
}
|
||||
|
||||
namespace wi
|
||||
{
|
||||
typedef poly_int<NUM_POLY_INT_COEFFS,
|
||||
generic_wide_int <wide_int_ref_storage <false, false> > >
|
||||
rtx_to_poly_wide_ref;
|
||||
rtx_to_poly_wide_ref to_poly_wide (const_rtx, machine_mode);
|
||||
}
|
||||
|
||||
/* Return the value of a CONST_POLY_INT in its native precision. */
|
||||
|
||||
inline wi::rtx_to_poly_wide_ref
|
||||
const_poly_int_value (const_rtx x)
|
||||
{
|
||||
poly_int<NUM_POLY_INT_COEFFS, WIDE_INT_REF_FOR (wide_int)> res;
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
res.coeffs[i] = CONST_POLY_INT_COEFFS (x)[i];
|
||||
return res;
|
||||
}
|
||||
|
||||
/* Return true if X is a scalar integer or a CONST_POLY_INT. The value
|
||||
can then be extracted using wi::to_poly_wide. */
|
||||
|
||||
inline bool
|
||||
poly_int_rtx_p (const_rtx x)
|
||||
{
|
||||
return CONST_SCALAR_INT_P (x) || CONST_POLY_INT_P (x);
|
||||
}
|
||||
|
||||
/* Access X (which satisfies poly_int_rtx_p) as a poly_wide_int.
|
||||
MODE is the mode of X. */
|
||||
|
||||
inline wi::rtx_to_poly_wide_ref
|
||||
wi::to_poly_wide (const_rtx x, machine_mode mode)
|
||||
{
|
||||
if (CONST_POLY_INT_P (x))
|
||||
return const_poly_int_value (x);
|
||||
return rtx_mode_t (const_cast<rtx> (x), mode);
|
||||
}
|
||||
|
||||
/* Return the value of X as a poly_int64. */
|
||||
|
||||
inline poly_int64
|
||||
rtx_to_poly_int64 (const_rtx x)
|
||||
{
|
||||
if (CONST_POLY_INT_P (x))
|
||||
{
|
||||
poly_int64 res;
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
res.coeffs[i] = CONST_POLY_INT_COEFFS (x)[i].to_shwi ();
|
||||
return res;
|
||||
}
|
||||
return INTVAL (x);
|
||||
}
|
||||
|
||||
/* Return true if arbitrary value X is an integer constant that can
|
||||
be represented as a poly_int64. Store the value in *RES if so,
|
||||
otherwise leave it unmodified. */
|
||||
|
||||
inline bool
|
||||
poly_int_rtx_p (const_rtx x, poly_int64_pod *res)
|
||||
{
|
||||
if (CONST_INT_P (x))
|
||||
{
|
||||
*res = INTVAL (x);
|
||||
return true;
|
||||
}
|
||||
if (CONST_POLY_INT_P (x))
|
||||
{
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
if (!wi::fits_shwi_p (CONST_POLY_INT_COEFFS (x)[i]))
|
||||
return false;
|
||||
for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
res->coeffs[i] = CONST_POLY_INT_COEFFS (x)[i].to_shwi ();
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
extern void init_rtlanal (void);
|
||||
extern int rtx_cost (rtx, machine_mode, enum rtx_code, int, bool);
|
||||
extern int address_cost (rtx, machine_mode, addr_space_t, bool);
|
||||
|
|
@ -2764,7 +2860,8 @@ get_full_set_src_cost (rtx x, machine_mode mode, struct full_rtx_costs *c)
|
|||
|
||||
/* In explow.c */
|
||||
extern HOST_WIDE_INT trunc_int_for_mode (HOST_WIDE_INT, machine_mode);
|
||||
extern rtx plus_constant (machine_mode, rtx, HOST_WIDE_INT, bool = false);
|
||||
extern poly_int64 trunc_int_for_mode (poly_int64, machine_mode);
|
||||
extern rtx plus_constant (machine_mode, rtx, poly_int64, bool = false);
|
||||
extern HOST_WIDE_INT get_stack_check_protect (void);
|
||||
|
||||
/* In rtl.c */
|
||||
|
|
@ -3058,13 +3155,11 @@ extern void end_sequence (void);
|
|||
extern double_int rtx_to_double_int (const_rtx);
|
||||
#endif
|
||||
extern void cwi_output_hex (FILE *, const_rtx);
|
||||
#ifndef GENERATOR_FILE
|
||||
extern rtx immed_wide_int_const (const wide_int_ref &, machine_mode);
|
||||
#endif
|
||||
#if TARGET_SUPPORTS_WIDE_INT == 0
|
||||
extern rtx immed_double_const (HOST_WIDE_INT, HOST_WIDE_INT,
|
||||
machine_mode);
|
||||
#endif
|
||||
extern rtx immed_wide_int_const (const poly_wide_int_ref &, machine_mode);
|
||||
|
||||
/* In varasm.c */
|
||||
extern rtx force_const_mem (machine_mode, rtx);
|
||||
|
|
@ -3252,6 +3347,7 @@ extern HOST_WIDE_INT get_integer_term (const_rtx);
|
|||
extern rtx get_related_value (const_rtx);
|
||||
extern bool offset_within_block_p (const_rtx, HOST_WIDE_INT);
|
||||
extern void split_const (rtx, rtx *, rtx *);
|
||||
extern rtx strip_offset (rtx, poly_int64_pod *);
|
||||
extern bool unsigned_reg_p (rtx);
|
||||
extern int reg_mentioned_p (const_rtx, const_rtx);
|
||||
extern int count_occurrences (const_rtx, const_rtx, int);
|
||||
|
|
@ -4185,6 +4281,21 @@ load_extend_op (machine_mode mode)
|
|||
return UNKNOWN;
|
||||
}
|
||||
|
||||
/* If X is a PLUS of a base and a constant offset, add the constant to *OFFSET
|
||||
and return the base. Return X otherwise. */
|
||||
|
||||
inline rtx
|
||||
strip_offset_and_add (rtx x, poly_int64_pod *offset)
|
||||
{
|
||||
if (GET_CODE (x) == PLUS)
|
||||
{
|
||||
poly_int64 suboffset;
|
||||
x = strip_offset (x, &suboffset);
|
||||
*offset += suboffset;
|
||||
}
|
||||
return x;
|
||||
}
|
||||
|
||||
/* gtype-desc.c. */
|
||||
extern void gt_ggc_mx (rtx &);
|
||||
extern void gt_pch_nx (rtx &);
|
||||
|
|
|
|||
|
|
@ -915,6 +915,28 @@ split_const (rtx x, rtx *base_out, rtx *offset_out)
|
|||
*base_out = x;
|
||||
*offset_out = const0_rtx;
|
||||
}
|
||||
|
||||
/* Express integer value X as some value Y plus a polynomial offset,
|
||||
where Y is either const0_rtx, X or something within X (as opposed
|
||||
to a new rtx). Return the Y and store the offset in *OFFSET_OUT. */
|
||||
|
||||
rtx
|
||||
strip_offset (rtx x, poly_int64_pod *offset_out)
|
||||
{
|
||||
rtx base = const0_rtx;
|
||||
rtx test = x;
|
||||
if (GET_CODE (test) == CONST)
|
||||
test = XEXP (test, 0);
|
||||
if (GET_CODE (test) == PLUS)
|
||||
{
|
||||
base = XEXP (test, 0);
|
||||
test = XEXP (test, 1);
|
||||
}
|
||||
if (poly_int_rtx_p (test, offset_out))
|
||||
return base;
|
||||
*offset_out = 0;
|
||||
return x;
|
||||
}
|
||||
|
||||
/* Return the number of places FIND appears within X. If COUNT_DEST is
|
||||
zero, we do not count occurrences inside the destination of a SET. */
|
||||
|
|
@ -3406,13 +3428,15 @@ commutative_operand_precedence (rtx op)
|
|||
|
||||
/* Constants always become the second operand. Prefer "nice" constants. */
|
||||
if (code == CONST_INT)
|
||||
return -8;
|
||||
return -10;
|
||||
if (code == CONST_WIDE_INT)
|
||||
return -7;
|
||||
return -9;
|
||||
if (code == CONST_POLY_INT)
|
||||
return -8;
|
||||
if (code == CONST_DOUBLE)
|
||||
return -7;
|
||||
return -8;
|
||||
if (code == CONST_FIXED)
|
||||
return -7;
|
||||
return -8;
|
||||
op = avoid_constant_pool_reference (op);
|
||||
code = GET_CODE (op);
|
||||
|
||||
|
|
@ -3420,13 +3444,15 @@ commutative_operand_precedence (rtx op)
|
|||
{
|
||||
case RTX_CONST_OBJ:
|
||||
if (code == CONST_INT)
|
||||
return -6;
|
||||
return -7;
|
||||
if (code == CONST_WIDE_INT)
|
||||
return -6;
|
||||
return -6;
|
||||
if (code == CONST_POLY_INT)
|
||||
return -5;
|
||||
if (code == CONST_DOUBLE)
|
||||
return -5;
|
||||
return -5;
|
||||
if (code == CONST_FIXED)
|
||||
return -5;
|
||||
return -5;
|
||||
return -4;
|
||||
|
||||
case RTX_EXTRA:
|
||||
|
|
|
|||
|
|
@ -55,6 +55,10 @@ add_rtx (const_rtx x, hash &hstate)
|
|||
for (i = 0; i < CONST_WIDE_INT_NUNITS (x); i++)
|
||||
hstate.add_object (CONST_WIDE_INT_ELT (x, i));
|
||||
return;
|
||||
case CONST_POLY_INT:
|
||||
for (i = 0; i < NUM_POLY_INT_COEFFS; ++i)
|
||||
hstate.add_wide_int (CONST_POLY_INT_COEFFS (x)[i]);
|
||||
break;
|
||||
case SYMBOL_REF:
|
||||
if (XSTR (x, 0))
|
||||
hstate.add (XSTR (x, 0), strlen (XSTR (x, 0)) + 1);
|
||||
|
|
|
|||
|
|
@ -2038,6 +2038,26 @@ simplify_const_unary_operation (enum rtx_code code, machine_mode mode,
|
|||
}
|
||||
}
|
||||
|
||||
/* Handle polynomial integers. */
|
||||
else if (CONST_POLY_INT_P (op))
|
||||
{
|
||||
poly_wide_int result;
|
||||
switch (code)
|
||||
{
|
||||
case NEG:
|
||||
result = -const_poly_int_value (op);
|
||||
break;
|
||||
|
||||
case NOT:
|
||||
result = ~const_poly_int_value (op);
|
||||
break;
|
||||
|
||||
default:
|
||||
return NULL_RTX;
|
||||
}
|
||||
return immed_wide_int_const (result, mode);
|
||||
}
|
||||
|
||||
return NULL_RTX;
|
||||
}
|
||||
|
||||
|
|
@ -2218,6 +2238,7 @@ simplify_binary_operation_1 (enum rtx_code code, machine_mode mode,
|
|||
rtx tem, reversed, opleft, opright, elt0, elt1;
|
||||
HOST_WIDE_INT val;
|
||||
scalar_int_mode int_mode, inner_mode;
|
||||
poly_int64 offset;
|
||||
|
||||
/* Even if we can't compute a constant result,
|
||||
there are some cases worth simplifying. */
|
||||
|
|
@ -2530,6 +2551,12 @@ simplify_binary_operation_1 (enum rtx_code code, machine_mode mode,
|
|||
return simplify_gen_binary (MINUS, mode, tem, XEXP (op0, 0));
|
||||
}
|
||||
|
||||
if ((GET_CODE (op0) == CONST
|
||||
|| GET_CODE (op0) == SYMBOL_REF
|
||||
|| GET_CODE (op0) == LABEL_REF)
|
||||
&& poly_int_rtx_p (op1, &offset))
|
||||
return plus_constant (mode, op0, trunc_int_for_mode (-offset, mode));
|
||||
|
||||
/* Don't let a relocatable value get a negative coeff. */
|
||||
if (CONST_INT_P (op1) && GET_MODE (op0) != VOIDmode)
|
||||
return simplify_gen_binary (PLUS, mode,
|
||||
|
|
@ -4327,6 +4354,57 @@ simplify_const_binary_operation (enum rtx_code code, machine_mode mode,
|
|||
return immed_wide_int_const (result, int_mode);
|
||||
}
|
||||
|
||||
/* Handle polynomial integers. */
|
||||
if (NUM_POLY_INT_COEFFS > 1
|
||||
&& is_a <scalar_int_mode> (mode, &int_mode)
|
||||
&& poly_int_rtx_p (op0)
|
||||
&& poly_int_rtx_p (op1))
|
||||
{
|
||||
poly_wide_int result;
|
||||
switch (code)
|
||||
{
|
||||
case PLUS:
|
||||
result = wi::to_poly_wide (op0, mode) + wi::to_poly_wide (op1, mode);
|
||||
break;
|
||||
|
||||
case MINUS:
|
||||
result = wi::to_poly_wide (op0, mode) - wi::to_poly_wide (op1, mode);
|
||||
break;
|
||||
|
||||
case MULT:
|
||||
if (CONST_SCALAR_INT_P (op1))
|
||||
result = wi::to_poly_wide (op0, mode) * rtx_mode_t (op1, mode);
|
||||
else
|
||||
return NULL_RTX;
|
||||
break;
|
||||
|
||||
case ASHIFT:
|
||||
if (CONST_SCALAR_INT_P (op1))
|
||||
{
|
||||
wide_int shift = rtx_mode_t (op1, mode);
|
||||
if (SHIFT_COUNT_TRUNCATED)
|
||||
shift = wi::umod_trunc (shift, GET_MODE_PRECISION (int_mode));
|
||||
else if (wi::geu_p (shift, GET_MODE_PRECISION (int_mode)))
|
||||
return NULL_RTX;
|
||||
result = wi::to_poly_wide (op0, mode) << shift;
|
||||
}
|
||||
else
|
||||
return NULL_RTX;
|
||||
break;
|
||||
|
||||
case IOR:
|
||||
if (!CONST_SCALAR_INT_P (op1)
|
||||
|| !can_ior_p (wi::to_poly_wide (op0, mode),
|
||||
rtx_mode_t (op1, mode), &result))
|
||||
return NULL_RTX;
|
||||
break;
|
||||
|
||||
default:
|
||||
return NULL_RTX;
|
||||
}
|
||||
return immed_wide_int_const (result, int_mode);
|
||||
}
|
||||
|
||||
return NULL_RTX;
|
||||
}
|
||||
|
||||
|
|
@ -6370,13 +6448,27 @@ simplify_subreg (machine_mode outermode, rtx op,
|
|||
scalar_int_mode int_outermode, int_innermode;
|
||||
if (is_a <scalar_int_mode> (outermode, &int_outermode)
|
||||
&& is_a <scalar_int_mode> (innermode, &int_innermode)
|
||||
&& (GET_MODE_PRECISION (int_outermode)
|
||||
< GET_MODE_PRECISION (int_innermode))
|
||||
&& byte == subreg_lowpart_offset (int_outermode, int_innermode))
|
||||
{
|
||||
rtx tem = simplify_truncation (int_outermode, op, int_innermode);
|
||||
if (tem)
|
||||
return tem;
|
||||
/* Handle polynomial integers. The upper bits of a paradoxical
|
||||
subreg are undefined, so this is safe regardless of whether
|
||||
we're truncating or extending. */
|
||||
if (CONST_POLY_INT_P (op))
|
||||
{
|
||||
poly_wide_int val
|
||||
= poly_wide_int::from (const_poly_int_value (op),
|
||||
GET_MODE_PRECISION (int_outermode),
|
||||
SIGNED);
|
||||
return immed_wide_int_const (val, int_outermode);
|
||||
}
|
||||
|
||||
if (GET_MODE_PRECISION (int_outermode)
|
||||
< GET_MODE_PRECISION (int_innermode))
|
||||
{
|
||||
rtx tem = simplify_truncation (int_outermode, op, int_innermode);
|
||||
if (tem)
|
||||
return tem;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL_RTX;
|
||||
|
|
@ -6685,12 +6777,60 @@ test_vector_ops ()
|
|||
}
|
||||
}
|
||||
|
||||
template<unsigned int N>
|
||||
struct simplify_const_poly_int_tests
|
||||
{
|
||||
static void run ();
|
||||
};
|
||||
|
||||
template<>
|
||||
struct simplify_const_poly_int_tests<1>
|
||||
{
|
||||
static void run () {}
|
||||
};
|
||||
|
||||
/* Test various CONST_POLY_INT properties. */
|
||||
|
||||
template<unsigned int N>
|
||||
void
|
||||
simplify_const_poly_int_tests<N>::run ()
|
||||
{
|
||||
rtx x1 = gen_int_mode (poly_int64 (1, 1), QImode);
|
||||
rtx x2 = gen_int_mode (poly_int64 (-80, 127), QImode);
|
||||
rtx x3 = gen_int_mode (poly_int64 (-79, -128), QImode);
|
||||
rtx x4 = gen_int_mode (poly_int64 (5, 4), QImode);
|
||||
rtx x5 = gen_int_mode (poly_int64 (30, 24), QImode);
|
||||
rtx x6 = gen_int_mode (poly_int64 (20, 16), QImode);
|
||||
rtx x7 = gen_int_mode (poly_int64 (7, 4), QImode);
|
||||
rtx x8 = gen_int_mode (poly_int64 (30, 24), HImode);
|
||||
rtx x9 = gen_int_mode (poly_int64 (-30, -24), HImode);
|
||||
rtx x10 = gen_int_mode (poly_int64 (-31, -24), HImode);
|
||||
rtx two = GEN_INT (2);
|
||||
rtx six = GEN_INT (6);
|
||||
HOST_WIDE_INT offset = subreg_lowpart_offset (QImode, HImode);
|
||||
|
||||
/* These tests only try limited operation combinations. Fuller arithmetic
|
||||
testing is done directly on poly_ints. */
|
||||
ASSERT_EQ (simplify_unary_operation (NEG, HImode, x8, HImode), x9);
|
||||
ASSERT_EQ (simplify_unary_operation (NOT, HImode, x8, HImode), x10);
|
||||
ASSERT_EQ (simplify_unary_operation (TRUNCATE, QImode, x8, HImode), x5);
|
||||
ASSERT_EQ (simplify_binary_operation (PLUS, QImode, x1, x2), x3);
|
||||
ASSERT_EQ (simplify_binary_operation (MINUS, QImode, x3, x1), x2);
|
||||
ASSERT_EQ (simplify_binary_operation (MULT, QImode, x4, six), x5);
|
||||
ASSERT_EQ (simplify_binary_operation (MULT, QImode, six, x4), x5);
|
||||
ASSERT_EQ (simplify_binary_operation (ASHIFT, QImode, x4, two), x6);
|
||||
ASSERT_EQ (simplify_binary_operation (IOR, QImode, x4, two), x7);
|
||||
ASSERT_EQ (simplify_subreg (HImode, x5, QImode, 0), x8);
|
||||
ASSERT_EQ (simplify_subreg (QImode, x8, HImode, offset), x5);
|
||||
}
|
||||
|
||||
/* Run all of the selftests within this file. */
|
||||
|
||||
void
|
||||
simplify_rtx_c_tests ()
|
||||
{
|
||||
test_vector_ops ();
|
||||
simplify_const_poly_int_tests<NUM_POLY_INT_COEFFS>::run ();
|
||||
}
|
||||
|
||||
} // namespace selftest
|
||||
|
|
|
|||
|
|
@ -613,6 +613,7 @@ namespace wi
|
|||
access. */
|
||||
struct storage_ref
|
||||
{
|
||||
storage_ref () {}
|
||||
storage_ref (const HOST_WIDE_INT *, unsigned int, unsigned int);
|
||||
|
||||
const HOST_WIDE_INT *val;
|
||||
|
|
@ -944,6 +945,8 @@ private:
|
|||
HOST_WIDE_INT scratch[2];
|
||||
|
||||
public:
|
||||
wide_int_ref_storage () {}
|
||||
|
||||
wide_int_ref_storage (const wi::storage_ref &);
|
||||
|
||||
template <typename T>
|
||||
|
|
@ -1323,7 +1326,7 @@ namespace wi
|
|||
bytes beyond the sizeof need to be allocated. Use set_precision
|
||||
to initialize the structure. */
|
||||
template <int N>
|
||||
class GTY(()) trailing_wide_ints
|
||||
class GTY((user)) trailing_wide_ints
|
||||
{
|
||||
private:
|
||||
/* The shared precision of each number. */
|
||||
|
|
@ -1340,9 +1343,14 @@ private:
|
|||
HOST_WIDE_INT m_val[1];
|
||||
|
||||
public:
|
||||
typedef WIDE_INT_REF_FOR (trailing_wide_int_storage) const_reference;
|
||||
|
||||
void set_precision (unsigned int);
|
||||
unsigned int get_precision () const { return m_precision; }
|
||||
trailing_wide_int operator [] (unsigned int);
|
||||
const_reference operator [] (unsigned int) const;
|
||||
static size_t extra_size (unsigned int);
|
||||
size_t extra_size () const { return extra_size (m_precision); }
|
||||
};
|
||||
|
||||
inline trailing_wide_int_storage::
|
||||
|
|
@ -1414,6 +1422,14 @@ trailing_wide_ints <N>::operator [] (unsigned int index)
|
|||
&m_val[index * m_max_len]);
|
||||
}
|
||||
|
||||
template <int N>
|
||||
inline typename trailing_wide_ints <N>::const_reference
|
||||
trailing_wide_ints <N>::operator [] (unsigned int index) const
|
||||
{
|
||||
return wi::storage_ref (&m_val[index * m_max_len],
|
||||
m_len[index], m_precision);
|
||||
}
|
||||
|
||||
/* Return how many extra bytes need to be added to the end of the structure
|
||||
in order to handle N wide_ints of precision PRECISION. */
|
||||
template <int N>
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue