| Message ID | 1452767177-31956-1-git-send-email-alan.lawrence@arm.com |
|---|---|
| State | New |
| Headers | show |
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 >
On 14/01/16 12:22, Richard Biener wrote: > 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. > I took that as an approval, and committed r232373. Thanks, Alan
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
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? 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(-)