[16/nn] Factor out the mode handling in lower-subreg.c

This patch adds a helper routine (interesting_mode_p) to lower-subreg.c,
to make the decision about whether a mode can be split and, if so,
calculate the number of bytes and words in the mode.  At present this
function always returns true; a later patch will add cases in which it
can return false.


2017-10-23  Richard Sandiford  <richard.sandiford@linaro.org>
	    Alan Hayward  <alan.hayward@arm.com>
	    David Sherwood  <david.sherwood@arm.com>

gcc/
	* lower-subreg.c (interesting_mode_p): New function.
	(compute_costs, find_decomposable_subregs, decompose_register)
	(simplify_subreg_concatn, can_decompose_p, resolve_simple_move)
	(resolve_clobber, dump_choices): Use it.

On Mon, Oct 23, 2017 at 1:27 PM, Richard Sandiford
<richard.sandiford@linaro.org> wrote:
> This patch adds a helper routine (interesting_mode_p) to lower-subreg.c,

> to make the decision about whether a mode can be split and, if so,

> calculate the number of bytes and words in the mode.  At present this

> function always returns true; a later patch will add cases in which it

> can return false.


Ok.

Richard.

>

> 2017-10-23  Richard Sandiford  <richard.sandiford@linaro.org>

>             Alan Hayward  <alan.hayward@arm.com>

>             David Sherwood  <david.sherwood@arm.com>

>

> gcc/

>         * lower-subreg.c (interesting_mode_p): New function.

>         (compute_costs, find_decomposable_subregs, decompose_register)

>         (simplify_subreg_concatn, can_decompose_p, resolve_simple_move)

>         (resolve_clobber, dump_choices): Use it.

>

> Index: gcc/lower-subreg.c

> ===================================================================

> --- gcc/lower-subreg.c  2017-10-23 11:47:11.274393237 +0100

> +++ gcc/lower-subreg.c  2017-10-23 11:47:23.555013148 +0100

> @@ -103,6 +103,18 @@ #define twice_word_mode \

>  #define choices \

>    this_target_lower_subreg->x_choices

>

> +/* Return true if MODE is a mode we know how to lower.  When returning true,

> +   store its byte size in *BYTES and its word size in *WORDS.  */

> +

> +static inline bool

> +interesting_mode_p (machine_mode mode, unsigned int *bytes,

> +                   unsigned int *words)

> +{

> +  *bytes = GET_MODE_SIZE (mode);

> +  *words = CEIL (*bytes, UNITS_PER_WORD);

> +  return true;

> +}

> +

>  /* RTXes used while computing costs.  */

>  struct cost_rtxes {

>    /* Source and target registers.  */

> @@ -199,10 +211,10 @@ compute_costs (bool speed_p, struct cost

>    for (i = 0; i < MAX_MACHINE_MODE; i++)

>      {

>        machine_mode mode = (machine_mode) i;

> -      int factor = GET_MODE_SIZE (mode) / UNITS_PER_WORD;

> -      if (factor > 1)

> +      unsigned int size, factor;

> +      if (interesting_mode_p (mode, &size, &factor) && factor > 1)

>         {

> -         int mode_move_cost;

> +         unsigned int mode_move_cost;

>

>           PUT_MODE (rtxes->target, mode);

>           PUT_MODE (rtxes->source, mode);

> @@ -469,10 +481,10 @@ find_decomposable_subregs (rtx *loc, enu

>               continue;

>             }

>

> -         outer_size = GET_MODE_SIZE (GET_MODE (x));

> -         inner_size = GET_MODE_SIZE (GET_MODE (inner));

> -         outer_words = (outer_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

> -         inner_words = (inner_size + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

> +         if (!interesting_mode_p (GET_MODE (x), &outer_size, &outer_words)

> +             || !interesting_mode_p (GET_MODE (inner), &inner_size,

> +                                     &inner_words))

> +           continue;

>

>           /* We only try to decompose single word subregs of multi-word

>              registers.  When we find one, we return -1 to avoid iterating

> @@ -507,7 +519,7 @@ find_decomposable_subregs (rtx *loc, enu

>         }

>        else if (REG_P (x))

>         {

> -         unsigned int regno;

> +         unsigned int regno, size, words;

>

>           /* We will see an outer SUBREG before we see the inner REG, so

>              when we see a plain REG here it means a direct reference to

> @@ -527,7 +539,8 @@ find_decomposable_subregs (rtx *loc, enu

>

>           regno = REGNO (x);

>           if (!HARD_REGISTER_NUM_P (regno)

> -             && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)

> +             && interesting_mode_p (GET_MODE (x), &size, &words)

> +             && words > 1)

>             {

>               switch (*pcmi)

>                 {

> @@ -567,15 +580,15 @@ find_decomposable_subregs (rtx *loc, enu

>  decompose_register (unsigned int regno)

>  {

>    rtx reg;

> -  unsigned int words, i;

> +  unsigned int size, words, i;

>    rtvec v;

>

>    reg = regno_reg_rtx[regno];

>

>    regno_reg_rtx[regno] = NULL_RTX;

>

> -  words = GET_MODE_SIZE (GET_MODE (reg));

> -  words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

> +  if (!interesting_mode_p (GET_MODE (reg), &size, &words))

> +    gcc_unreachable ();

>

>    v = rtvec_alloc (words);

>    for (i = 0; i < words; ++i)

> @@ -599,25 +612,29 @@ decompose_register (unsigned int regno)

>  simplify_subreg_concatn (machine_mode outermode, rtx op,

>                          unsigned int byte)

>  {

> -  unsigned int inner_size;

> +  unsigned int outer_size, outer_words, inner_size, inner_words;

>    machine_mode innermode, partmode;

>    rtx part;

>    unsigned int final_offset;

>

> +  innermode = GET_MODE (op);

> +  if (!interesting_mode_p (outermode, &outer_size, &outer_words)

> +      || !interesting_mode_p (innermode, &inner_size, &inner_words))

> +    gcc_unreachable ();

> +

>    gcc_assert (GET_CODE (op) == CONCATN);

> -  gcc_assert (byte % GET_MODE_SIZE (outermode) == 0);

> +  gcc_assert (byte % outer_size == 0);

>

> -  innermode = GET_MODE (op);

> -  gcc_assert (byte < GET_MODE_SIZE (innermode));

> -  if (GET_MODE_SIZE (outermode) > GET_MODE_SIZE (innermode))

> +  gcc_assert (byte < inner_size);

> +  if (outer_size > inner_size)

>      return NULL_RTX;

>

> -  inner_size = GET_MODE_SIZE (innermode) / XVECLEN (op, 0);

> +  inner_size /= XVECLEN (op, 0);

>    part = XVECEXP (op, 0, byte / inner_size);

>    partmode = GET_MODE (part);

>

>    final_offset = byte % inner_size;

> -  if (final_offset + GET_MODE_SIZE (outermode) > inner_size)

> +  if (final_offset + outer_size > inner_size)

>      return NULL_RTX;

>

>    /* VECTOR_CSTs in debug expressions are expanded into CONCATN instead of

> @@ -801,9 +818,10 @@ can_decompose_p (rtx x)

>

>        if (HARD_REGISTER_NUM_P (regno))

>         {

> -         unsigned int byte, num_bytes;

> +         unsigned int byte, num_bytes, num_words;

>

> -         num_bytes = GET_MODE_SIZE (GET_MODE (x));

> +         if (!interesting_mode_p (GET_MODE (x), &num_bytes, &num_words))

> +           return false;

>           for (byte = 0; byte < num_bytes; byte += UNITS_PER_WORD)

>             if (simplify_subreg_regno (regno, GET_MODE (x), byte, word_mode) < 0)

>               return false;

> @@ -826,14 +844,15 @@ resolve_simple_move (rtx set, rtx_insn *

>    rtx src, dest, real_dest;

>    rtx_insn *insns;

>    machine_mode orig_mode, dest_mode;

> -  unsigned int words;

> +  unsigned int orig_size, words;

>    bool pushing;

>

>    src = SET_SRC (set);

>    dest = SET_DEST (set);

>    orig_mode = GET_MODE (dest);

>

> -  words = (GET_MODE_SIZE (orig_mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

> +  if (!interesting_mode_p (orig_mode, &orig_size, &words))

> +    gcc_unreachable ();

>    gcc_assert (words > 1);

>

>    start_sequence ();

> @@ -964,7 +983,7 @@ resolve_simple_move (rtx set, rtx_insn *

>      {

>        unsigned int i, j, jinc;

>

> -      gcc_assert (GET_MODE_SIZE (orig_mode) % UNITS_PER_WORD == 0);

> +      gcc_assert (orig_size % UNITS_PER_WORD == 0);

>        gcc_assert (GET_CODE (XEXP (dest, 0)) != PRE_MODIFY);

>        gcc_assert (GET_CODE (XEXP (dest, 0)) != POST_MODIFY);

>

> @@ -1059,7 +1078,7 @@ resolve_clobber (rtx pat, rtx_insn *insn

>  {

>    rtx reg;

>    machine_mode orig_mode;

> -  unsigned int words, i;

> +  unsigned int orig_size, words, i;

>    int ret;

>

>    reg = XEXP (pat, 0);

> @@ -1067,8 +1086,8 @@ resolve_clobber (rtx pat, rtx_insn *insn

>      return false;

>

>    orig_mode = GET_MODE (reg);

> -  words = GET_MODE_SIZE (orig_mode);

> -  words = (words + UNITS_PER_WORD - 1) / UNITS_PER_WORD;

> +  if (!interesting_mode_p (orig_mode, &orig_size, &words))

> +    gcc_unreachable ();

>

>    ret = validate_change (NULL_RTX, &XEXP (pat, 0),

>                          simplify_gen_subreg_concatn (word_mode, reg,

> @@ -1332,12 +1351,13 @@ dump_shift_choices (enum rtx_code code,

>  static void

>  dump_choices (bool speed_p, const char *description)

>  {

> -  unsigned int i;

> +  unsigned int size, factor, i;

>

>    fprintf (dump_file, "Choices when optimizing for %s:\n", description);

>

>    for (i = 0; i < MAX_MACHINE_MODE; i++)

> -    if (GET_MODE_SIZE ((machine_mode) i) > UNITS_PER_WORD)

> +    if (interesting_mode_p ((machine_mode) i, &size, &factor)

> +       && factor > 1)

>        fprintf (dump_file, "  %s mode %s for copy lowering.\n",

>                choices[speed_p].move_modes_to_split[i]

>                ? "Splitting"