This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [18/nn] Use (CONST_VECTOR|GET_MODE)_NUNITS in simplify-rtx.c
- From: Richard Biener <richard dot guenther at gmail dot com>
- To: GCC Patches <gcc-patches at gcc dot gnu dot org>, Richard Sandiford <richard dot sandiford at linaro dot org>
- Date: Thu, 26 Oct 2017 14:10:33 +0200
- Subject: Re: [18/nn] Use (CONST_VECTOR|GET_MODE)_NUNITS in simplify-rtx.c
- Authentication-results: sourceware.org; auth=none
- References: <87wp3mxgir.fsf@linaro.org> <87r2tuumqn.fsf@linaro.org>
On Mon, Oct 23, 2017 at 1:28 PM, Richard Sandiford
<richard.sandiford@linaro.org> wrote:
> This patch avoids some calculations of the form:
>
> GET_MODE_SIZE (vector_mode) / GET_MODE_SIZE (element_mode)
>
> in simplify-rtx.c. If we're dealing with CONST_VECTORs, it's better
> to use CONST_VECTOR_NUNITS, since that remains constant even after the
> SVE patches. In other cases we can get the number from GET_MODE_NUNITS.
Ok.
Richard.
>
> 2017-10-23 Richard Sandiford <richard.sandiford@linaro.org>
> Alan Hayward <alan.hayward@arm.com>
> David Sherwood <david.sherwood@arm.com>
>
> gcc/
> * simplify-rtx.c (simplify_const_unary_operation): Use GET_MODE_NUNITS
> and CONST_VECTOR_NUNITS instead of computing the number of units from
> the byte sizes of the vector and element.
> (simplify_binary_operation_1): Likewise.
> (simplify_const_binary_operation): Likewise.
> (simplify_ternary_operation): Likewise.
>
> Index: gcc/simplify-rtx.c
> ===================================================================
> --- gcc/simplify-rtx.c 2017-10-23 11:47:11.277288162 +0100
> +++ gcc/simplify-rtx.c 2017-10-23 11:47:32.868935554 +0100
> @@ -1752,18 +1752,12 @@ simplify_const_unary_operation (enum rtx
> return gen_const_vec_duplicate (mode, op);
> if (GET_CODE (op) == CONST_VECTOR)
> {
> - int elt_size = GET_MODE_UNIT_SIZE (mode);
> - unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
> - rtvec v = rtvec_alloc (n_elts);
> - unsigned int i;
> -
> - machine_mode inmode = GET_MODE (op);
> - int in_elt_size = GET_MODE_UNIT_SIZE (inmode);
> - unsigned in_n_elts = (GET_MODE_SIZE (inmode) / in_elt_size);
> -
> + unsigned int n_elts = GET_MODE_NUNITS (mode);
> + unsigned int in_n_elts = CONST_VECTOR_NUNITS (op);
> gcc_assert (in_n_elts < n_elts);
> gcc_assert ((n_elts % in_n_elts) == 0);
> - for (i = 0; i < n_elts; i++)
> + rtvec v = rtvec_alloc (n_elts);
> + for (unsigned i = 0; i < n_elts; i++)
> RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op, i % in_n_elts);
> return gen_rtx_CONST_VECTOR (mode, v);
> }
> @@ -3608,9 +3602,7 @@ simplify_binary_operation_1 (enum rtx_co
> rtx op0 = XEXP (trueop0, 0);
> rtx op1 = XEXP (trueop0, 1);
>
> - machine_mode opmode = GET_MODE (op0);
> - int elt_size = GET_MODE_UNIT_SIZE (opmode);
> - int n_elts = GET_MODE_SIZE (opmode) / elt_size;
> + int n_elts = GET_MODE_NUNITS (GET_MODE (op0));
>
> int i = INTVAL (XVECEXP (trueop1, 0, 0));
> int elem;
> @@ -3637,21 +3629,8 @@ simplify_binary_operation_1 (enum rtx_co
> mode01 = GET_MODE (op01);
>
> /* Find out number of elements of each operand. */
> - if (VECTOR_MODE_P (mode00))
> - {
> - elt_size = GET_MODE_UNIT_SIZE (mode00);
> - n_elts00 = GET_MODE_SIZE (mode00) / elt_size;
> - }
> - else
> - n_elts00 = 1;
> -
> - if (VECTOR_MODE_P (mode01))
> - {
> - elt_size = GET_MODE_UNIT_SIZE (mode01);
> - n_elts01 = GET_MODE_SIZE (mode01) / elt_size;
> - }
> - else
> - n_elts01 = 1;
> + n_elts00 = GET_MODE_NUNITS (mode00);
> + n_elts01 = GET_MODE_NUNITS (mode01);
>
> gcc_assert (n_elts == n_elts00 + n_elts01);
>
> @@ -3771,9 +3750,8 @@ simplify_binary_operation_1 (enum rtx_co
> rtx subop1 = XEXP (trueop0, 1);
> machine_mode mode0 = GET_MODE (subop0);
> machine_mode mode1 = GET_MODE (subop1);
> - int li = GET_MODE_UNIT_SIZE (mode0);
> - int l0 = GET_MODE_SIZE (mode0) / li;
> - int l1 = GET_MODE_SIZE (mode1) / li;
> + int l0 = GET_MODE_NUNITS (mode0);
> + int l1 = GET_MODE_NUNITS (mode1);
> int i0 = INTVAL (XVECEXP (trueop1, 0, 0));
> if (i0 == 0 && !side_effects_p (op1) && mode == mode0)
> {
> @@ -3931,14 +3909,10 @@ simplify_binary_operation_1 (enum rtx_co
> || CONST_SCALAR_INT_P (trueop1)
> || CONST_DOUBLE_AS_FLOAT_P (trueop1)))
> {
> - int elt_size = GET_MODE_UNIT_SIZE (mode);
> - unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
> + unsigned n_elts = GET_MODE_NUNITS (mode);
> + unsigned in_n_elts = GET_MODE_NUNITS (op0_mode);
> rtvec v = rtvec_alloc (n_elts);
> unsigned int i;
> - unsigned in_n_elts = 1;
> -
> - if (VECTOR_MODE_P (op0_mode))
> - in_n_elts = (GET_MODE_SIZE (op0_mode) / elt_size);
> for (i = 0; i < n_elts; i++)
> {
> if (i < in_n_elts)
> @@ -4026,16 +4000,12 @@ simplify_const_binary_operation (enum rt
> && GET_CODE (op0) == CONST_VECTOR
> && GET_CODE (op1) == CONST_VECTOR)
> {
> - unsigned n_elts = GET_MODE_NUNITS (mode);
> - machine_mode op0mode = GET_MODE (op0);
> - unsigned op0_n_elts = GET_MODE_NUNITS (op0mode);
> - machine_mode op1mode = GET_MODE (op1);
> - unsigned op1_n_elts = GET_MODE_NUNITS (op1mode);
> + unsigned int n_elts = CONST_VECTOR_NUNITS (op0);
> + gcc_assert (n_elts == (unsigned int) CONST_VECTOR_NUNITS (op1));
> + gcc_assert (n_elts == GET_MODE_NUNITS (mode));
> rtvec v = rtvec_alloc (n_elts);
> unsigned int i;
>
> - gcc_assert (op0_n_elts == n_elts);
> - gcc_assert (op1_n_elts == n_elts);
> for (i = 0; i < n_elts; i++)
> {
> rtx x = simplify_binary_operation (code, GET_MODE_INNER (mode),
> @@ -5712,8 +5682,7 @@ simplify_ternary_operation (enum rtx_cod
> trueop2 = avoid_constant_pool_reference (op2);
> if (CONST_INT_P (trueop2))
> {
> - int elt_size = GET_MODE_UNIT_SIZE (mode);
> - unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size);
> + unsigned n_elts = GET_MODE_NUNITS (mode);
> unsigned HOST_WIDE_INT sel = UINTVAL (trueop2);
> unsigned HOST_WIDE_INT mask;
> if (n_elts == HOST_BITS_PER_WIDE_INT)