diff mbox series

[COMMITTED] Add an unreachable_path_p method to path_range_query.

Message ID 20210905130717.836593-1-aldyh@redhat.com
State New
Headers show
Series [COMMITTED] Add an unreachable_path_p method to path_range_query. | expand

Commit Message

Aldy Hernandez Sept. 5, 2021, 1:07 p.m. UTC 
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.
---
 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 mbox series

Patch

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<basic_block> &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<basic_block> &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);