Re: [PATCH] Tidy: remove reduc_xxx_optab migration code

[Richard Biener <richard dot guenther at gmail dot com>]

On Thu, Jan 14, 2016 at 11:26 AM, Alan Lawrence <alan.lawrence@arm.com> wrote:
> If/when mips-ps-3d.md is moved from reduc_* to reduc_*_scal optabs (patch here:
> https://gcc.gnu.org/ml/gcc-patches/2016-01/msg00311.html ), there will be no
> uses of the old reduc_* optabs remaining. This patch removes those optabs and
> the migration path.
>
> Bootstrapped + check-gcc + check-g++ on x86_64 and AArch64.
>
> I'm not sure whether such a code tidy is acceptable for stage 3, please advise?

Yes, this is still very much welcome.

Thanks,
Richard.

> Thanks, Alan
>
> gcc/ChangeLog:
>
>         * doc/md.texi (reduc_smin_@var{m}, reduc_smax_@var{m},
>         reduc_umin_@var{m}, reduc_umax_@var{m}, reduc_splus_@var{m},
>         reduc_uplus_@var{m}): Remove.
>         * expr.c (expand_expr_real_2): Remove expansion path for
>         reduc_[us](min|max|plus) optabs.
>         * optabs-tree.c (scalar_reduc_to_vector): Remove.
>         * optabs-tree.h (scalar_reduc_to_vector): Remove.
>         * optabs.def (reduc_smax_optab, reduc_smin_optab, reduc_splus_optab,
>         reduc_umax_optab, reduc_umin_optab, reduc_uplus_optab): Remove.
>         * tree-vect-loop.c (vectorizable_reduction): Remove test for
>         reduc_[us](min|max|plus) optabs.
> ---
>  gcc/doc/md.texi      | 27 ---------------------------
>  gcc/expr.c           | 39 ++++++++++-----------------------------
>  gcc/optabs-tree.c    | 20 --------------------
>  gcc/optabs-tree.h    |  1 -
>  gcc/optabs.def       |  7 -------
>  gcc/tree-vect-loop.c | 12 ++++--------
>  6 files changed, 14 insertions(+), 92 deletions(-)
>
> diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi
> index faf3910..68321dc 100644
> --- a/gcc/doc/md.texi
> +++ b/gcc/doc/md.texi
> @@ -5007,33 +5007,6 @@ raised and a quiet @code{NaN} is returned.
>  All operands have mode @var{m}, which is a scalar or vector
>  floating-point mode.  These patterns are not allowed to @code{FAIL}.
>
> -@cindex @code{reduc_smin_@var{m}} instruction pattern
> -@cindex @code{reduc_smax_@var{m}} instruction pattern
> -@item @samp{reduc_smin_@var{m}}, @samp{reduc_smax_@var{m}}
> -Find the signed minimum/maximum of the elements of a vector. The vector is
> -operand 1, and the result is stored in the least significant bits of
> -operand 0 (also a vector). The output and input vector should have the same
> -modes. These are legacy optabs, and platforms should prefer to implement
> -@samp{reduc_smin_scal_@var{m}} and @samp{reduc_smax_scal_@var{m}}.
> -
> -@cindex @code{reduc_umin_@var{m}} instruction pattern
> -@cindex @code{reduc_umax_@var{m}} instruction pattern
> -@item @samp{reduc_umin_@var{m}}, @samp{reduc_umax_@var{m}}
> -Find the unsigned minimum/maximum of the elements of a vector. The vector is
> -operand 1, and the result is stored in the least significant bits of
> -operand 0 (also a vector). The output and input vector should have the same
> -modes. These are legacy optabs, and platforms should prefer to implement
> -@samp{reduc_umin_scal_@var{m}} and @samp{reduc_umax_scal_@var{m}}.
> -
> -@cindex @code{reduc_splus_@var{m}} instruction pattern
> -@cindex @code{reduc_uplus_@var{m}} instruction pattern
> -@item @samp{reduc_splus_@var{m}}, @samp{reduc_uplus_@var{m}}
> -Compute the sum of the signed/unsigned elements of a vector. The vector is
> -operand 1, and the result is stored in the least significant bits of operand 0
> -(also a vector). The output and input vector should have the same modes.
> -These are legacy optabs, and platforms should prefer to implement
> -@samp{reduc_plus_scal_@var{m}}.
> -
>  @cindex @code{reduc_smin_scal_@var{m}} instruction pattern
>  @cindex @code{reduc_smax_scal_@var{m}} instruction pattern
>  @item @samp{reduc_smin_scal_@var{m}}, @samp{reduc_smax_scal_@var{m}}
> diff --git a/gcc/expr.c b/gcc/expr.c
> index 8973893..e1ed44d 100644
> --- a/gcc/expr.c
> +++ b/gcc/expr.c
> @@ -9164,35 +9164,16 @@ expand_expr_real_2 (sepops ops, rtx target, machine_mode tmode,
>          this_optab = optab_for_tree_code (code, type, optab_default);
>          machine_mode vec_mode = TYPE_MODE (TREE_TYPE (treeop0));
>
> -       if (optab_handler (this_optab, vec_mode) != CODE_FOR_nothing)
> -         {
> -           struct expand_operand ops[2];
> -           enum insn_code icode = optab_handler (this_optab, vec_mode);
> -
> -           create_output_operand (&ops[0], target, mode);
> -           create_input_operand (&ops[1], op0, vec_mode);
> -           if (maybe_expand_insn (icode, 2, ops))
> -             {
> -               target = ops[0].value;
> -               if (GET_MODE (target) != mode)
> -                 return gen_lowpart (tmode, target);
> -               return target;
> -             }
> -         }
> -       /* Fall back to optab with vector result, and then extract scalar.  */
> -       this_optab = scalar_reduc_to_vector (this_optab, type);
> -        temp = expand_unop (vec_mode, this_optab, op0, NULL_RTX, unsignedp);
> -        gcc_assert (temp);
> -        /* The tree code produces a scalar result, but (somewhat by convention)
> -           the optab produces a vector with the result in element 0 if
> -           little-endian, or element N-1 if big-endian.  So pull the scalar
> -           result out of that element.  */
> -        int index = BYTES_BIG_ENDIAN ? GET_MODE_NUNITS (vec_mode) - 1 : 0;
> -       int bitsize = GET_MODE_UNIT_BITSIZE (vec_mode);
> -        temp = extract_bit_field (temp, bitsize, bitsize * index, unsignedp,
> -                                 target, mode, mode, false);
> -        gcc_assert (temp);
> -        return temp;
> +       struct expand_operand ops[2];
> +       enum insn_code icode = optab_handler (this_optab, vec_mode);
> +
> +       create_output_operand (&ops[0], target, mode);
> +       create_input_operand (&ops[1], op0, vec_mode);
> +       expand_insn (icode, 2, ops);
> +       target = ops[0].value;
> +       if (GET_MODE (target) != mode)
> +         return gen_lowpart (tmode, target);
> +       return target;
>        }
>
>      case VEC_UNPACK_HI_EXPR:
> diff --git a/gcc/optabs-tree.c b/gcc/optabs-tree.c
> index d9dd3fc..a229b97 100644
> --- a/gcc/optabs-tree.c
> +++ b/gcc/optabs-tree.c
> @@ -246,26 +246,6 @@ optab_for_tree_code (enum tree_code code, const_tree type,
>      }
>  }
>
> -/* Given optab UNOPTAB that reduces a vector to a scalar, find instead the old
> -   optab that produces a vector with the reduction result in one element,
> -   for a tree with type TYPE.  */
> -
> -optab
> -scalar_reduc_to_vector (optab unoptab, const_tree type)
> -{
> -  switch (unoptab)
> -    {
> -    case reduc_plus_scal_optab:
> -      return TYPE_UNSIGNED (type) ? reduc_uplus_optab : reduc_splus_optab;
> -
> -    case reduc_smin_scal_optab: return reduc_smin_optab;
> -    case reduc_umin_scal_optab: return reduc_umin_optab;
> -    case reduc_smax_scal_optab: return reduc_smax_optab;
> -    case reduc_umax_scal_optab: return reduc_umax_optab;
> -    default: return unknown_optab;
> -    }
> -}
> -
>  /* Function supportable_convert_operation
>
>     Check whether an operation represented by the code CODE is a
> diff --git a/gcc/optabs-tree.h b/gcc/optabs-tree.h
> index 0727925..c3b9280 100644
> --- a/gcc/optabs-tree.h
> +++ b/gcc/optabs-tree.h
> @@ -36,7 +36,6 @@ enum optab_subtype
>     the second argument.  The third argument distinguishes between the types of
>     vector shifts and rotates.  */
>  optab optab_for_tree_code (enum tree_code, const_tree, enum optab_subtype);
> -optab scalar_reduc_to_vector (optab, const_tree);
>  bool supportable_convert_operation (enum tree_code, tree, tree, tree *,
>                                     enum tree_code *);
>  bool expand_vec_cmp_expr_p (tree, tree);
> diff --git a/gcc/optabs.def b/gcc/optabs.def
> index 4faedc6..c938b42 100644
> --- a/gcc/optabs.def
> +++ b/gcc/optabs.def
> @@ -285,13 +285,6 @@ OPTAB_D (reduc_smin_scal_optab, "reduc_smin_scal_$a")
>  OPTAB_D (reduc_plus_scal_optab, "reduc_plus_scal_$a")
>  OPTAB_D (reduc_umax_scal_optab, "reduc_umax_scal_$a")
>  OPTAB_D (reduc_umin_scal_optab, "reduc_umin_scal_$a")
> -/* (Old) Vector reduction, returning a vector with the result in one lane.  */
> -OPTAB_D (reduc_smax_optab, "reduc_smax_$a")
> -OPTAB_D (reduc_smin_optab, "reduc_smin_$a")
> -OPTAB_D (reduc_splus_optab, "reduc_splus_$a")
> -OPTAB_D (reduc_umax_optab, "reduc_umax_$a")
> -OPTAB_D (reduc_umin_optab, "reduc_umin_$a")
> -OPTAB_D (reduc_uplus_optab, "reduc_uplus_$a")
>
>  OPTAB_D (sdot_prod_optab, "sdot_prod$I$a")
>  OPTAB_D (ssum_widen_optab, "widen_ssum$I$a3")
> diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c
> index a82cf26..d658d9b 100644
> --- a/gcc/tree-vect-loop.c
> +++ b/gcc/tree-vect-loop.c
> @@ -5743,15 +5743,11 @@ vectorizable_reduction (gimple *stmt, gimple_stmt_iterator *gsi,
>             }
>           else if (optab_handler (reduc_optab, vec_mode) == CODE_FOR_nothing)
>             {
> -             optab = scalar_reduc_to_vector (reduc_optab, vectype_out);
> -             if (optab_handler (optab, vec_mode) == CODE_FOR_nothing)
> -               {
> -                 if (dump_enabled_p ())
> -                   dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> -                                    "reduc op not supported by target.\n");
> +             if (dump_enabled_p ())
> +               dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
> +                                "reduc op not supported by target.\n");
>
> -                 epilog_reduc_code = ERROR_MARK;
> -               }
> +             epilog_reduc_code = ERROR_MARK;
>             }
>
>           /* When epilog_reduc_code is ERROR_MARK then a reduction will be
> --
> 1.9.1
>