From 83325a9db8348c3ba5e9c871d106ee1b76d40526 Mon Sep 17 00:00:00 2001 From: Jakub Jelinek Date: Fri, 27 Nov 2020 11:38:31 +0100 Subject: [PATCH] tree-ssanames: Allow non-SSA_NAME arguments to get_range_info My recent match.pd change required quite a lot of code due to the separate need to handle INTEGER_CSTs and SSA_NAMEs, and after all, I didn't even handle one case there, when in x * y / y the x is INTEGER_CST and y is SSA_NAME. The following patch allows to simplify it, by allowing non-SSA_NAME argument to get_range_info, for INTEGER_CSTs it will return VR_RANGE with *min == *max equal to the constnat, and for non-INTEGER_CST/SSA_NAMEs it will just return VR_VARYING. This allows not to simplify just the match.pd, but some other spots too. 2020-11-27 Jakub Jelinek * tree-ssanames.c (get_range_info): Handle INTEGER_CST by returning VR_RANGE with both *min and *max set to the wide_int value of the INTEGER_CST. Return VR_VARYING for non-SSA_NAMEs. * match.pd ((t * 2) / 2) -> t): Handle also @0 being INTEGER_CST. Simplify by calling get_range_info on everything. * tree-ssa-strlen.c (maybe_diag_stxncpy_trunc): Simplify by calling get_range_info on everything. * tree-scalar-evolution.c (iv_can_overflow_p): Likewise. --- gcc/match.pd | 60 ++++++++++++++++++--------------------------- gcc/tree-scalar-evolution.c | 18 +++----------- gcc/tree-ssa-strlen.c | 35 +++++++++++--------------- gcc/tree-ssanames.c | 19 ++++++++++---- 4 files changed, 56 insertions(+), 76 deletions(-) diff --git a/gcc/match.pd b/gcc/match.pd index b6dfc24..1726c18 100644 --- a/gcc/match.pd +++ b/gcc/match.pd @@ -654,42 +654,30 @@ DEFINE_INT_AND_FLOAT_ROUND_FN (RINT) (if (TYPE_OVERFLOW_UNDEFINED (type)) @0 #if GIMPLE - (if (TREE_CODE (@0) == SSA_NAME - && (TREE_CODE (@1) == SSA_NAME || TREE_CODE (@1) == INTEGER_CST)) - (with - { - bool overflowed = true; - wide_int wmin0, wmax0; - if (get_range_info (@0, &wmin0, &wmax0) == VR_RANGE) - { - /* If the multiplication can't overflow/wrap around, then - it can be optimized too. */ - wide_int wmin1, wmax1; - wi::overflow_type min_ovf, max_ovf; - if (TREE_CODE (@1) == INTEGER_CST) - { - wmin1 = wi::to_wide (@1); - wi::mul (wmin0, wmin1, TYPE_SIGN (type), &min_ovf); - wi::mul (wmax0, wmin1, TYPE_SIGN (type), &max_ovf); - if (min_ovf == wi::OVF_NONE && max_ovf == wi::OVF_NONE) - overflowed = false; - } - else if (get_range_info (@1, &wmin1, &wmax1) == VR_RANGE) - { - wi::mul (wmin0, wmin1, TYPE_SIGN (type), &min_ovf); - wi::mul (wmax0, wmax1, TYPE_SIGN (type), &max_ovf); - if (min_ovf == wi::OVF_NONE && max_ovf == wi::OVF_NONE) - { - wi::mul (wmin0, wmax1, TYPE_SIGN (type), &min_ovf); - wi::mul (wmax0, wmin1, TYPE_SIGN (type), &max_ovf); - if (min_ovf == wi::OVF_NONE && max_ovf == wi::OVF_NONE) - overflowed = false; - } - } - } - } - (if (!overflowed) - @0))) + (with + { + bool overflowed = true; + wide_int wmin0, wmax0, wmin1, wmax1; + if (INTEGRAL_TYPE_P (type) + && get_range_info (@0, &wmin0, &wmax0) == VR_RANGE + && get_range_info (@1, &wmin1, &wmax1) == VR_RANGE) + { + /* If the multiplication can't overflow/wrap around, then + it can be optimized too. */ + wi::overflow_type min_ovf, max_ovf; + wi::mul (wmin0, wmin1, TYPE_SIGN (type), &min_ovf); + wi::mul (wmax0, wmax1, TYPE_SIGN (type), &max_ovf); + if (min_ovf == wi::OVF_NONE && max_ovf == wi::OVF_NONE) + { + wi::mul (wmin0, wmax1, TYPE_SIGN (type), &min_ovf); + wi::mul (wmax0, wmin1, TYPE_SIGN (type), &max_ovf); + if (min_ovf == wi::OVF_NONE && max_ovf == wi::OVF_NONE) + overflowed = false; + } + } + } + (if (!overflowed) + @0)) #endif )))) diff --git a/gcc/tree-scalar-evolution.c b/gcc/tree-scalar-evolution.c index edab778..2c7923d 100644 --- a/gcc/tree-scalar-evolution.c +++ b/gcc/tree-scalar-evolution.c @@ -3043,22 +3043,12 @@ iv_can_overflow_p (class loop *loop, tree type, tree base, tree step) if (integer_zerop (step)) return false; - if (TREE_CODE (base) == INTEGER_CST) - base_min = base_max = wi::to_wide (base); - else if (TREE_CODE (base) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (base)) - && get_range_info (base, &base_min, &base_max) == VR_RANGE) - ; - else + if (!INTEGRAL_TYPE_P (TREE_TYPE (base)) + || get_range_info (base, &base_min, &base_max) != VR_RANGE) return true; - if (TREE_CODE (step) == INTEGER_CST) - step_min = step_max = wi::to_wide (step); - else if (TREE_CODE (step) == SSA_NAME - && INTEGRAL_TYPE_P (TREE_TYPE (step)) - && get_range_info (step, &step_min, &step_max) == VR_RANGE) - ; - else + if (!INTEGRAL_TYPE_P (TREE_TYPE (step)) + || get_range_info (step, &step_min, &step_max) != VR_RANGE) return true; if (!get_max_loop_iterations (loop, &nit)) diff --git a/gcc/tree-ssa-strlen.c b/gcc/tree-ssa-strlen.c index a5e78a8..f365c2d 100644 --- a/gcc/tree-ssa-strlen.c +++ b/gcc/tree-ssa-strlen.c @@ -3038,31 +3038,24 @@ maybe_diag_stxncpy_trunc (gimple_stmt_iterator gsi, tree src, tree cnt) wide_int cntrange[2]; - if (TREE_CODE (cnt) == INTEGER_CST) - cntrange[0] = cntrange[1] = wi::to_wide (cnt); - else if (TREE_CODE (cnt) == SSA_NAME) + // FIXME: Use range_query instead of global ranges. + enum value_range_kind rng = get_range_info (cnt, cntrange, cntrange + 1); + if (rng == VR_RANGE) + ; + else if (rng == VR_ANTI_RANGE) { - // FIXME: Use range_query instead of global ranges. - enum value_range_kind rng = get_range_info (cnt, cntrange, cntrange + 1); - if (rng == VR_RANGE) - ; - else if (rng == VR_ANTI_RANGE) - { - wide_int maxobjsize = wi::to_wide (TYPE_MAX_VALUE (ptrdiff_type_node)); + wide_int maxobjsize = wi::to_wide (TYPE_MAX_VALUE (ptrdiff_type_node)); - if (wi::ltu_p (cntrange[1], maxobjsize)) - { - cntrange[0] = cntrange[1] + 1; - cntrange[1] = maxobjsize; - } - else - { - cntrange[1] = cntrange[0] - 1; - cntrange[0] = wi::zero (TYPE_PRECISION (TREE_TYPE (cnt))); - } + if (wi::ltu_p (cntrange[1], maxobjsize)) + { + cntrange[0] = cntrange[1] + 1; + cntrange[1] = maxobjsize; } else - return false; + { + cntrange[1] = cntrange[0] - 1; + cntrange[0] = wi::zero (TYPE_PRECISION (TREE_TYPE (cnt))); + } } else return false; diff --git a/gcc/tree-ssanames.c b/gcc/tree-ssanames.c index ec4681f..1b9dcec 100644 --- a/gcc/tree-ssanames.c +++ b/gcc/tree-ssanames.c @@ -420,21 +420,30 @@ set_range_info (tree name, const value_range &vr) is used to determine if MIN and MAX are valid values. */ enum value_range_kind -get_range_info (const_tree name, wide_int *min, wide_int *max) +get_range_info (const_tree expr, wide_int *min, wide_int *max) { - gcc_assert (!POINTER_TYPE_P (TREE_TYPE (name))); + gcc_assert (!POINTER_TYPE_P (TREE_TYPE (expr))); gcc_assert (min && max); - range_info_def *ri = SSA_NAME_RANGE_INFO (name); + if (TREE_CODE (expr) == INTEGER_CST) + { + *min = wi::to_wide (expr); + *max = *min; + return VR_RANGE; + } + if (TREE_CODE (expr) != SSA_NAME) + return VR_VARYING; + + range_info_def *ri = SSA_NAME_RANGE_INFO (expr); /* Return VR_VARYING for SSA_NAMEs with NULL RANGE_INFO or SSA_NAMEs with integral types width > 2 * HOST_BITS_PER_WIDE_INT precision. */ - if (!ri || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (name))) + if (!ri || (GET_MODE_PRECISION (SCALAR_INT_TYPE_MODE (TREE_TYPE (expr))) > 2 * HOST_BITS_PER_WIDE_INT)) return VR_VARYING; *min = ri->get_min (); *max = ri->get_max (); - return SSA_NAME_RANGE_TYPE (name); + return SSA_NAME_RANGE_TYPE (expr); } /* Gets range information corresponding to ssa_name NAME and stores it -- 2.7.4