From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 2136) id 8118D385840E; Sun, 5 Sep 2021 13:01:49 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 8118D385840E MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Type: text/plain; charset="utf-8" From: Aldy Hernandez To: gcc-cvs@gcc.gnu.org Subject: [gcc r12-3358] Add an unreachable_path_p method to path_range_query. X-Act-Checkin: gcc X-Git-Author: Aldy Hernandez X-Git-Refname: refs/heads/master X-Git-Oldrev: cbeeadff4c041c09a6335105d596019b6d583880 X-Git-Newrev: 90ef15352701c6880faee83a46031d7837ab9d27 Message-Id: <20210905130149.8118D385840E@sourceware.org> Date: Sun, 5 Sep 2021 13:01:49 +0000 (GMT) X-BeenThere: gcc-cvs@gcc.gnu.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Gcc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 05 Sep 2021 13:01:49 -0000 https://gcc.gnu.org/g:90ef15352701c6880faee83a46031d7837ab9d27 commit r12-3358-g90ef15352701c6880faee83a46031d7837ab9d27 Author: Aldy Hernandez Date: Sun Sep 5 12:44:41 2021 +0200 Add an unreachable_path_p method to path_range_query. Keeping track of unreachable calculations while traversing a path is useful to determine edge reachability, among other things. We've been doing this ad-hoc in the backwards threader, so this provides a cleaner way of accessing the information. This patch also makes it easier to compare different threading implementations, in some upcoming work. For example, it's currently difficult to gague how good we're doing compared to the forward threader, because it can thread paths that are obviously unreachable. This provides a way of discarding those paths. Note that I've opted to keep unreachable_path_p() out-of-line, because I have local changes that will enhance this method. Tested on x86-64 Linux. gcc/ChangeLog: * gimple-range-path.cc (path_range_query::range_of_expr): Set m_undefined_path when appropriate. (path_range_query::internal_range_of_expr): Copy from range_of_expr. (path_range_query::unreachable_path_p): New. (path_range_query::precompute_ranges): Set m_undefined_path. * gimple-range-path.h (path_range_query::unreachable_path_p): New. (path_range_query::internal_range_of_expr): New. * tree-ssa-threadbackward.c (back_threader::find_taken_edge_cond): Use unreachable_path_p. Diff: --- gcc/gimple-range-path.cc | 22 +++++++++++++++++++++- gcc/gimple-range-path.h | 6 ++++++ gcc/tree-ssa-threadbackward.c | 14 ++++---------- 3 files changed, 31 insertions(+), 11 deletions(-) diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc index db15eb3ff22..f4509b5a726 100644 --- a/gcc/gimple-range-path.cc +++ b/gcc/gimple-range-path.cc @@ -115,7 +115,7 @@ path_range_query::debug () // Return the range of NAME at the end of the path being analyzed. bool -path_range_query::range_of_expr (irange &r, tree name, gimple *stmt) +path_range_query::internal_range_of_expr (irange &r, tree name, gimple *stmt) { if (!irange::supports_type_p (TREE_TYPE (name))) return false; @@ -135,6 +135,25 @@ path_range_query::range_of_expr (irange &r, tree name, gimple *stmt) return true; } +bool +path_range_query::range_of_expr (irange &r, tree name, gimple *stmt) +{ + if (internal_range_of_expr (r, name, stmt)) + { + if (r.undefined_p ()) + m_undefined_path = true; + + return true; + } + return false; +} + +bool +path_range_query::unreachable_path_p () +{ + return m_undefined_path; +} + // Return the range of STMT at the end of the path being analyzed. // Anything but the final conditional in a BB will return VARYING. @@ -345,6 +364,7 @@ path_range_query::precompute_ranges (const vec &path, { set_path (path); m_imports = imports; + m_undefined_path = false; if (DEBUG_SOLVER) { diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h index 51773131040..c75721f6dc0 100644 --- a/gcc/gimple-range-path.h +++ b/gcc/gimple-range-path.h @@ -41,10 +41,13 @@ public: const bitmap_head *imports); bool range_of_expr (irange &r, tree name, gimple * = NULL) override; bool range_of_stmt (irange &r, gimple *, tree name = NULL) override; + bool unreachable_path_p (); void dump (FILE *) override; void debug (); private: + bool internal_range_of_expr (irange &r, tree name, gimple *); + // Cache manipulation. void set_cache (const irange &r, tree name); bool get_cache (irange &r, tree name); @@ -82,6 +85,9 @@ private: const bitmap_head *m_imports; gimple_ranger &m_ranger; non_null_ref m_non_null; + + // Set if there were any undefined expressions while pre-calculating path. + bool m_undefined_path; }; #endif // GCC_TREE_SSA_THREADSOLVER_H diff --git a/gcc/tree-ssa-threadbackward.c b/gcc/tree-ssa-threadbackward.c index 6827d008fb1..449232c7715 100644 --- a/gcc/tree-ssa-threadbackward.c +++ b/gcc/tree-ssa-threadbackward.c @@ -213,20 +213,14 @@ edge back_threader::find_taken_edge_cond (const vec &path, gcond *cond) { - m_solver.precompute_ranges (path, m_imports); - - // Check if either operand is unreachable since this knowledge could - // help the caller cut down the search space. int_range_max r; - m_solver.range_of_expr (r, gimple_cond_lhs (cond)); - if (r.undefined_p ()) - return UNREACHABLE_EDGE; - m_solver.range_of_expr (r, gimple_cond_rhs (cond)); - if (r.undefined_p ()) - return UNREACHABLE_EDGE; + m_solver.precompute_ranges (path, m_imports); m_solver.range_of_stmt (r, cond); + if (m_solver.unreachable_path_p ()) + return UNREACHABLE_EDGE; + int_range<2> true_range (boolean_true_node, boolean_true_node); int_range<2> false_range (boolean_false_node, boolean_false_node);