| Message ID | 87inhlmgyj.fsf@linaro.org |
|---|---|
| State | New |
| Headers | show |
On 08/18/2017 02:13 AM, Richard Sandiford wrote: > This patch adds a partial_integral_type_p function, to go along > with the full_integral_type_p added by the previous patch. > > Of the changes that didn't previously have an INTEGRAL_TYPE_P check: > > - the convert_to_integer_1 hunks are dominated by a case version > of INTEGRAL_TYPE_P. > > - the merge_ranges hunk is dominated by an ENUMERAL_TYPE case. > > - vectorizable_reduction has the comment: > > /* Do not try to vectorize bit-precision reductions. */ > > and so I think was only concerned with integers. > > - vectorizable_assignment has the comment: > > /* We do not handle bit-precision changes. */ > > and the later: > > /* But a conversion that does not change the bit-pattern is ok. */ > && !((TYPE_PRECISION (TREE_TYPE (scalar_dest)) > > TYPE_PRECISION (TREE_TYPE (op))) > && TYPE_UNSIGNED (TREE_TYPE (op))) > > would only make sense if OP is also an integral type. > > - vectorizable_shift is inherently restricted to integers. > > Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? > > Richard > > > 2017-08-17 Richard Sandiford <richard.sandiford@linaro.org> > Alan Hayward <alan.hayward@arm.com> > David Sherwood <david.sherwood@arm.com> > > gcc/ > * tree.h (partial_integral_type_p): New function. > * convert.c (convert_to_integer_1): Use it. > * expr.c (store_fieldexpand_expr_real_2, expand_expr_real_1): Likewise. > * fold-const.c (merge_ranges): Likewise. > * tree-ssa-math-opts.c (convert_mult_to_fma): Likewise. > * tree-tailcall.c (process_assignment): Likewise. > * tree-vect-loop.c (vectorizable_reduction): Likewise. > * tree-vect-stmts.c (vectorizable_conversion): Likewise. > (vectorizable_assignment, vectorizable_shift): Likewise. > > Index: gcc/tree.h > =================================================================== > --- gcc/tree.h 2017-08-18 08:35:58.031690315 +0100 > +++ gcc/tree.h 2017-08-18 08:36:07.208306339 +0100 > @@ -5414,4 +5414,13 @@ full_integral_type_p (const_tree t) > return INTEGRAL_TYPE_P (t) && scalar_type_is_full_p (t); > } > > +/* Return true if T is an integral type that has fewer bits than > + its underlying mode. */ May I suggest to rephrase that as "has fewer bits of precision than..." to make it clear what those bits refer to? Alternatively. "type whose precision is less than that of its underlying mode." > + > +inline bool > +partial_integral_type_p (const_tree t) > +{ > + return INTEGRAL_TYPE_P (t) && !scalar_type_is_full_p (t); > +} > + Martin
On 08/18/2017 02:13 AM, Richard Sandiford wrote: > This patch adds a partial_integral_type_p function, to go along > with the full_integral_type_p added by the previous patch. > > Of the changes that didn't previously have an INTEGRAL_TYPE_P check: > > - the convert_to_integer_1 hunks are dominated by a case version > of INTEGRAL_TYPE_P. > > - the merge_ranges hunk is dominated by an ENUMERAL_TYPE case. > > - vectorizable_reduction has the comment: > > /* Do not try to vectorize bit-precision reductions. */ > > and so I think was only concerned with integers. > > - vectorizable_assignment has the comment: > > /* We do not handle bit-precision changes. */ > > and the later: > > /* But a conversion that does not change the bit-pattern is ok. */ > && !((TYPE_PRECISION (TREE_TYPE (scalar_dest)) > > TYPE_PRECISION (TREE_TYPE (op))) > && TYPE_UNSIGNED (TREE_TYPE (op))) > > would only make sense if OP is also an integral type. > > - vectorizable_shift is inherently restricted to integers. > > Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? > > Richard > > > 2017-08-17 Richard Sandiford <richard.sandiford@linaro.org> > Alan Hayward <alan.hayward@arm.com> > David Sherwood <david.sherwood@arm.com> > > gcc/ > * tree.h (partial_integral_type_p): New function. > * convert.c (convert_to_integer_1): Use it. > * expr.c (store_fieldexpand_expr_real_2, expand_expr_real_1): Likewise. > * fold-const.c (merge_ranges): Likewise. > * tree-ssa-math-opts.c (convert_mult_to_fma): Likewise. > * tree-tailcall.c (process_assignment): Likewise. > * tree-vect-loop.c (vectorizable_reduction): Likewise. > * tree-vect-stmts.c (vectorizable_conversion): Likewise. > (vectorizable_assignment, vectorizable_shift): Likewise. OK. jeff
On 08/25/2017 10:48 AM, Martin Sebor wrote: > On 08/18/2017 02:13 AM, Richard Sandiford wrote: >> This patch adds a partial_integral_type_p function, to go along >> with the full_integral_type_p added by the previous patch. >> >> Of the changes that didn't previously have an INTEGRAL_TYPE_P check: >> >> - the convert_to_integer_1 hunks are dominated by a case version >> of INTEGRAL_TYPE_P. >> >> - the merge_ranges hunk is dominated by an ENUMERAL_TYPE case. >> >> - vectorizable_reduction has the comment: >> >> /* Do not try to vectorize bit-precision reductions. */ >> >> and so I think was only concerned with integers. >> >> - vectorizable_assignment has the comment: >> >> /* We do not handle bit-precision changes. */ >> >> and the later: >> >> /* But a conversion that does not change the bit-pattern is ok. */ >> && !((TYPE_PRECISION (TREE_TYPE (scalar_dest)) >> > TYPE_PRECISION (TREE_TYPE (op))) >> && TYPE_UNSIGNED (TREE_TYPE (op))) >> >> would only make sense if OP is also an integral type. >> >> - vectorizable_shift is inherently restricted to integers. >> >> Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? >> >> Richard >> >> >> 2017-08-17 Richard Sandiford <richard.sandiford@linaro.org> >> Alan Hayward <alan.hayward@arm.com> >> David Sherwood <david.sherwood@arm.com> >> >> gcc/ >> * tree.h (partial_integral_type_p): New function. >> * convert.c (convert_to_integer_1): Use it. >> * expr.c (store_fieldexpand_expr_real_2, expand_expr_real_1): >> Likewise. >> * fold-const.c (merge_ranges): Likewise. >> * tree-ssa-math-opts.c (convert_mult_to_fma): Likewise. >> * tree-tailcall.c (process_assignment): Likewise. >> * tree-vect-loop.c (vectorizable_reduction): Likewise. >> * tree-vect-stmts.c (vectorizable_conversion): Likewise. >> (vectorizable_assignment, vectorizable_shift): Likewise. >> >> Index: gcc/tree.h >> =================================================================== >> --- gcc/tree.h 2017-08-18 08:35:58.031690315 +0100 >> +++ gcc/tree.h 2017-08-18 08:36:07.208306339 +0100 >> @@ -5414,4 +5414,13 @@ full_integral_type_p (const_tree t) >> return INTEGRAL_TYPE_P (t) && scalar_type_is_full_p (t); >> } >> >> +/* Return true if T is an integral type that has fewer bits than >> + its underlying mode. */ > > May I suggest to rephrase that as "has fewer bits of precision > than..." to make it clear what those bits refer to? Alternatively. > "type whose precision is less than that of its underlying mode." Can't hurt to be a bit more precise for those who haven't had the pleasure of dealing with partial modes. Jeff
Index: gcc/tree.h =================================================================== --- gcc/tree.h 2017-08-18 08:35:58.031690315 +0100 +++ gcc/tree.h 2017-08-18 08:36:07.208306339 +0100 @@ -5414,4 +5414,13 @@ full_integral_type_p (const_tree t) return INTEGRAL_TYPE_P (t) && scalar_type_is_full_p (t); } +/* Return true if T is an integral type that has fewer bits than + its underlying mode. */ + +inline bool +partial_integral_type_p (const_tree t) +{ + return INTEGRAL_TYPE_P (t) && !scalar_type_is_full_p (t); +} + #endif /* GCC_TREE_H */ Index: gcc/convert.c =================================================================== --- gcc/convert.c 2017-08-10 14:36:09.015436664 +0100 +++ gcc/convert.c 2017-08-18 08:36:07.203306339 +0100 @@ -711,8 +711,7 @@ convert_to_integer_1 (tree type, tree ex the signed-to-unsigned case the high-order bits have to be cleared. */ if (TYPE_UNSIGNED (type) != TYPE_UNSIGNED (TREE_TYPE (expr)) - && (TYPE_PRECISION (TREE_TYPE (expr)) - != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (expr))))) + && partial_integral_type_p (TREE_TYPE (expr))) code = CONVERT_EXPR; else code = NOP_EXPR; @@ -725,7 +724,7 @@ convert_to_integer_1 (tree type, tree ex type corresponding to its mode, then do a nop conversion to TYPE. */ else if (TREE_CODE (type) == ENUMERAL_TYPE - || outprec != GET_MODE_PRECISION (TYPE_MODE (type))) + || partial_integral_type_p (type)) { expr = convert (lang_hooks.types.type_for_mode (TYPE_MODE (type), TYPE_UNSIGNED (type)), expr); Index: gcc/expr.c =================================================================== --- gcc/expr.c 2017-08-03 10:40:54.807600276 +0100 +++ gcc/expr.c 2017-08-18 08:36:07.204306339 +0100 @@ -6834,8 +6834,7 @@ store_field (rtx target, HOST_WIDE_INT b if (nop_def) { tree type = TREE_TYPE (exp); - if (INTEGRAL_TYPE_P (type) - && TYPE_PRECISION (type) < GET_MODE_BITSIZE (TYPE_MODE (type)) + if (partial_integral_type_p (type) && bitsize == TYPE_PRECISION (type)) { tree op = gimple_assign_rhs1 (nop_def); @@ -8243,8 +8242,7 @@ #define REDUCE_BIT_FIELD(expr) (reduce_b /* An operation in what may be a bit-field type needs the result to be reduced to the precision of the bit-field type, which is narrower than that of the type's mode. */ - reduce_bit_field = (INTEGRAL_TYPE_P (type) - && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type)); + reduce_bit_field = partial_integral_type_p (type); if (reduce_bit_field && modifier == EXPAND_STACK_PARM) target = 0; @@ -9669,9 +9667,7 @@ expand_expr_real_1 (tree exp, rtx target /* An operation in what may be a bit-field type needs the result to be reduced to the precision of the bit-field type, which is narrower than that of the type's mode. */ - reduce_bit_field = (!ignore - && INTEGRAL_TYPE_P (type) - && GET_MODE_PRECISION (mode) > TYPE_PRECISION (type)); + reduce_bit_field = (!ignore && partial_integral_type_p (type)); /* If we are going to ignore this result, we need only do something if there is a side-effect somewhere in the expression. If there Index: gcc/fold-const.c =================================================================== --- gcc/fold-const.c 2017-08-18 08:35:58.028990315 +0100 +++ gcc/fold-const.c 2017-08-18 08:36:07.206306339 +0100 @@ -5063,8 +5063,7 @@ merge_ranges (int *pin_p, tree *plow, tr switch (TREE_CODE (TREE_TYPE (low0))) { case ENUMERAL_TYPE: - if (TYPE_PRECISION (TREE_TYPE (low0)) - != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (low0)))) + if (partial_integral_type_p (TREE_TYPE (low0))) break; /* FALLTHROUGH */ case INTEGER_TYPE: @@ -5086,8 +5085,7 @@ merge_ranges (int *pin_p, tree *plow, tr switch (TREE_CODE (TREE_TYPE (high1))) { case ENUMERAL_TYPE: - if (TYPE_PRECISION (TREE_TYPE (high1)) - != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (high1)))) + if (partial_integral_type_p (TREE_TYPE (high1))) break; /* FALLTHROUGH */ case INTEGER_TYPE: Index: gcc/tree-ssa-math-opts.c =================================================================== --- gcc/tree-ssa-math-opts.c 2017-08-10 14:36:07.848478816 +0100 +++ gcc/tree-ssa-math-opts.c 2017-08-18 08:36:07.206306339 +0100 @@ -3563,9 +3563,7 @@ convert_mult_to_fma (gimple *mul_stmt, t return false; /* We don't want to do bitfield reduction ops. */ - if (INTEGRAL_TYPE_P (type) - && (TYPE_PRECISION (type) - != GET_MODE_PRECISION (TYPE_MODE (type)))) + if (partial_integral_type_p (type)) return false; /* If the target doesn't support it, don't generate it. We assume that Index: gcc/tree-tailcall.c =================================================================== --- gcc/tree-tailcall.c 2017-06-30 12:50:37.493697233 +0100 +++ gcc/tree-tailcall.c 2017-08-18 08:36:07.206306339 +0100 @@ -288,9 +288,7 @@ process_assignment (gassign *stmt, /* Even if the type modes are the same, if the precision of the type is smaller than mode's precision, reduce_to_bit_field_precision would generate additional code. */ - if (INTEGRAL_TYPE_P (TREE_TYPE (dest)) - && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (dest))) - > TYPE_PRECISION (TREE_TYPE (dest)))) + if (partial_integral_type_p (TREE_TYPE (dest))) return FAIL; } Index: gcc/tree-vect-loop.c =================================================================== --- gcc/tree-vect-loop.c 2017-08-16 08:50:54.198550019 +0100 +++ gcc/tree-vect-loop.c 2017-08-18 08:36:07.207306339 +0100 @@ -5848,8 +5848,7 @@ vectorizable_reduction (gimple *stmt, gi return false; /* Do not try to vectorize bit-precision reductions. */ - if ((TYPE_PRECISION (scalar_type) - != GET_MODE_PRECISION (TYPE_MODE (scalar_type)))) + if (partial_integral_type_p (scalar_type)) return false; /* All uses but the last are expected to be defined in the loop. Index: gcc/tree-vect-stmts.c =================================================================== --- gcc/tree-vect-stmts.c 2017-08-17 09:05:42.987968487 +0100 +++ gcc/tree-vect-stmts.c 2017-08-18 08:36:07.208306339 +0100 @@ -4097,12 +4097,8 @@ vectorizable_conversion (gimple *stmt, g return false; if (!VECTOR_BOOLEAN_TYPE_P (vectype_out) - && ((INTEGRAL_TYPE_P (lhs_type) - && (TYPE_PRECISION (lhs_type) - != GET_MODE_PRECISION (TYPE_MODE (lhs_type)))) - || (INTEGRAL_TYPE_P (rhs_type) - && (TYPE_PRECISION (rhs_type) - != GET_MODE_PRECISION (TYPE_MODE (rhs_type)))))) + && (partial_integral_type_p (lhs_type) + || partial_integral_type_p (rhs_type))) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location, @@ -4696,10 +4692,8 @@ vectorizable_assignment (gimple *stmt, g if ((CONVERT_EXPR_CODE_P (code) || code == VIEW_CONVERT_EXPR) && INTEGRAL_TYPE_P (TREE_TYPE (scalar_dest)) - && ((TYPE_PRECISION (TREE_TYPE (scalar_dest)) - != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (scalar_dest)))) - || ((TYPE_PRECISION (TREE_TYPE (op)) - != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (op)))))) + && (partial_integral_type_p (TREE_TYPE (scalar_dest)) + || partial_integral_type_p (TREE_TYPE (op))) /* But a conversion that does not change the bit-pattern is ok. */ && !((TYPE_PRECISION (TREE_TYPE (scalar_dest)) > TYPE_PRECISION (TREE_TYPE (op))) @@ -4875,8 +4869,7 @@ vectorizable_shift (gimple *stmt, gimple scalar_dest = gimple_assign_lhs (stmt); vectype_out = STMT_VINFO_VECTYPE (stmt_info); - if (TYPE_PRECISION (TREE_TYPE (scalar_dest)) - != GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (scalar_dest)))) + if (partial_integral_type_p (TREE_TYPE (scalar_dest))) { if (dump_enabled_p ()) dump_printf_loc (MSG_MISSED_OPTIMIZATION, vect_location,
This patch adds a partial_integral_type_p function, to go along with the full_integral_type_p added by the previous patch. Of the changes that didn't previously have an INTEGRAL_TYPE_P check: - the convert_to_integer_1 hunks are dominated by a case version of INTEGRAL_TYPE_P. - the merge_ranges hunk is dominated by an ENUMERAL_TYPE case. - vectorizable_reduction has the comment: /* Do not try to vectorize bit-precision reductions. */ and so I think was only concerned with integers. - vectorizable_assignment has the comment: /* We do not handle bit-precision changes. */ and the later: /* But a conversion that does not change the bit-pattern is ok. */ && !((TYPE_PRECISION (TREE_TYPE (scalar_dest)) > TYPE_PRECISION (TREE_TYPE (op))) && TYPE_UNSIGNED (TREE_TYPE (op))) would only make sense if OP is also an integral type. - vectorizable_shift is inherently restricted to integers. Tested on aarch64-linux-gnu and x86_64-linux-gnu. OK to install? Richard 2017-08-17 Richard Sandiford <richard.sandiford@linaro.org> Alan Hayward <alan.hayward@arm.com> David Sherwood <david.sherwood@arm.com> gcc/ * tree.h (partial_integral_type_p): New function. * convert.c (convert_to_integer_1): Use it. * expr.c (store_fieldexpand_expr_real_2, expand_expr_real_1): Likewise. * fold-const.c (merge_ranges): Likewise. * tree-ssa-math-opts.c (convert_mult_to_fma): Likewise. * tree-tailcall.c (process_assignment): Likewise. * tree-vect-loop.c (vectorizable_reduction): Likewise. * tree-vect-stmts.c (vectorizable_conversion): Likewise. (vectorizable_assignment, vectorizable_shift): Likewise.