[gcc r12-5131] path solver: Adjustments for use outside of the backward threader.

[gcc r12-5131] path solver: Adjustments for use outside of the backward threader.

[Aldy Hernandez]

https://gcc.gnu.org/g:b0c83d59f44bf677c8d74acae228acf32719acb3

commit r12-5131-gb0c83d59f44bf677c8d74acae228acf32719acb3
Author: Aldy Hernandez <aldyh@redhat.com>
Date:   Wed Nov 10 11:13:09 2021 +0100

    path solver: Adjustments for use outside of the backward threader.
    
    Here are some enhancements to make it easier for other clients to use
    the path solver.
    
    First, I've made the imports to the solver optional since we can
    calculate them ourselves.  However, I've left the ability to set them,
    since the backward threader adds a few SSA names in addition to the
    default ones.  As a follow-up I may move all the import set up code
    from the threader to the solver, as the extra imports tend to improve
    the behavior slightly.
    
    Second, Richi suggested an entry point where you just feed the solver
    an edge, which will be quite convenient for a subsequent patch adding
    a client in the header copying pass.  The required some shuffling,
    since we'll be adding the blocks on the fly.  There's now a vector
    copy, but the impact will be minimal, since these are just 5-6 entries
    at the most.
    
    Tested on ppc64le Linux.
    
    gcc/ChangeLog:
    
            * gimple-range-path.cc (path_range_query::path_range_query): Do
            not init m_path.
            (path_range_query::dump): Change m_path uses to non-pointer.
            (path_range_query::defined_outside_path):  Same.
            (path_range_query::set_path): Same.
            (path_range_query::add_copies_to_imports): Same.
            (path_range_query::range_of_stmt): Same.
            (path_range_query::compute_outgoing_relations): Same.
            (path_range_query::compute_ranges): Imports are now optional.
            Implement overload that takes an edge.
            * gimple-range-path.h (class path_range_query): Make imports
            optional for compute_ranges.  Add compute_ranges(edge) overload.
            Make m_path an auto_vec instead of a pointer and adjust
            accordingly.

Diff:
---
 gcc/gimple-range-path.cc | 41 ++++++++++++++++++++++++++++++-----------
 gcc/gimple-range-path.h  | 17 +++++++++--------
 2 files changed, 39 insertions(+), 19 deletions(-)

diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 99ac947581b..6da01c7067f 100644
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -41,7 +41,6 @@ path_range_query::path_range_query (gimple_ranger &ranger, bool resolve)
 {
   m_cache = new ssa_global_cache;
   m_has_cache_entry = BITMAP_ALLOC (NULL);
-  m_path = NULL;
   m_resolve = resolve;
   m_oracle = new path_oracle (ranger.oracle ());
 }
@@ -92,13 +91,13 @@ path_range_query::dump (FILE *dump_file)
 {
   push_dump_file save (dump_file, dump_flags & ~TDF_DETAILS);
 
-  if (m_path->is_empty ())
+  if (m_path.is_empty ())
     return;
 
   unsigned i;
   bitmap_iterator bi;
 
-  dump_ranger (dump_file, *m_path);
+  dump_ranger (dump_file, m_path);
 
   fprintf (dump_file, "Imports:\n");
   EXECUTE_IF_SET_IN_BITMAP (m_imports, 0, i, bi)
@@ -125,7 +124,7 @@ path_range_query::defined_outside_path (tree name)
   gimple *def = SSA_NAME_DEF_STMT (name);
   basic_block bb = gimple_bb (def);
 
-  return !bb || !m_path->contains (bb);
+  return !bb || !m_path.contains (bb);
 }
 
 // Return the range of NAME on entry to the path.
@@ -230,8 +229,8 @@ void
 path_range_query::set_path (const vec<basic_block> &path)
 {
   gcc_checking_assert (path.length () > 1);
-  m_path = &path;
-  m_pos = m_path->length () - 1;
+  m_path = path.copy ();
+  m_pos = m_path.length () - 1;
   bitmap_clear (m_has_cache_entry);
 }
 
@@ -486,7 +485,7 @@ path_range_query::add_copies_to_imports ()
 	      tree arg = gimple_phi_arg (phi, i)->def;
 
 	      if (TREE_CODE (arg) == SSA_NAME
-		  && m_path->contains (e->src)
+		  && m_path.contains (e->src)
 		  && bitmap_set_bit (m_imports, SSA_NAME_VERSION (arg)))
 		worklist.safe_push (arg);
 	    }
@@ -497,7 +496,8 @@ path_range_query::add_copies_to_imports ()
 // Compute the ranges for IMPORTS along PATH.
 //
 // IMPORTS are the set of SSA names, any of which could potentially
-// change the value of the final conditional in PATH.
+// change the value of the final conditional in PATH.  Default to the
+// imports of the last block in the path if none is given.
 
 void
 path_range_query::compute_ranges (const vec<basic_block> &path,
@@ -507,9 +507,16 @@ path_range_query::compute_ranges (const vec<basic_block> &path,
     fprintf (dump_file, "\n==============================================\n");
 
   set_path (path);
-  bitmap_copy (m_imports, imports);
   m_undefined_path = false;
 
+  if (imports)
+    bitmap_copy (m_imports, imports);
+  else
+    {
+      bitmap imports = m_ranger.gori ().imports (exit_bb ());
+      bitmap_copy (m_imports, imports);
+    }
+
   if (m_resolve)
     {
       add_copies_to_imports ();
@@ -561,6 +568,18 @@ path_range_query::compute_ranges (const vec<basic_block> &path,
     }
 }
 
+// Convenience function to compute ranges along a path consisting of
+// E->SRC and E->DEST.
+
+void
+path_range_query::compute_ranges (edge e)
+{
+  auto_vec<basic_block> bbs (2);
+  bbs.quick_push (e->dest);
+  bbs.quick_push (e->src);
+  compute_ranges (bbs);
+}
+
 // A folding aid used to register and query relations along a path.
 // When queried, it returns relations as they would appear on exit to
 // the path.
@@ -643,7 +662,7 @@ path_range_query::range_of_stmt (irange &r, gimple *stmt, tree)
   if (m_resolve)
     {
       fold_using_range f;
-      jt_fur_source src (stmt, this, &m_ranger.gori (), *m_path);
+      jt_fur_source src (stmt, this, &m_ranger.gori (), m_path);
       if (!f.fold_stmt (r, stmt, src))
 	r.set_varying (type);
     }
@@ -734,7 +753,7 @@ path_range_query::compute_outgoing_relations (basic_block bb, basic_block next)
       else
 	gcc_unreachable ();
 
-      jt_fur_source src (NULL, this, &m_ranger.gori (), *m_path);
+      jt_fur_source src (NULL, this, &m_ranger.gori (), m_path);
       src.register_outgoing_edges (cond, r, e0, e1);
     }
 }
diff --git a/gcc/gimple-range-path.h b/gcc/gimple-range-path.h
index f21d07f71c4..b73549f01a5 100644
--- a/gcc/gimple-range-path.h
+++ b/gcc/gimple-range-path.h
@@ -34,7 +34,8 @@ class path_range_query : public range_query
 public:
   path_range_query (class gimple_ranger &ranger, bool resolve);
   virtual ~path_range_query ();
-  void compute_ranges (const vec<basic_block> &, const bitmap_head *imports);
+  void compute_ranges (const vec<basic_block> &, const bitmap_head *imports = NULL);
+  void compute_ranges (edge e);
   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 ();
@@ -66,12 +67,12 @@ private:
 
   // Path navigation.
   void set_path (const vec<basic_block> &);
-  basic_block entry_bb () { return (*m_path)[m_path->length () - 1]; }
-  basic_block exit_bb ()  { return (*m_path)[0]; }
-  basic_block curr_bb ()  { return (*m_path)[m_pos]; }
-  basic_block prev_bb ()  { return (*m_path)[m_pos + 1]; }
-  basic_block next_bb ()  { return (*m_path)[m_pos - 1]; }
-  bool at_entry ()	  { return m_pos == m_path->length () - 1; }
+  basic_block entry_bb () { return m_path[m_path.length () - 1]; }
+  basic_block exit_bb ()  { return m_path[0]; }
+  basic_block curr_bb ()  { return m_path[m_pos]; }
+  basic_block prev_bb ()  { return m_path[m_pos + 1]; }
+  basic_block next_bb ()  { return m_path[m_pos - 1]; }
+  bool at_entry ()	  { return m_pos == m_path.length () - 1; }
   bool at_exit ()	  { return m_pos == 0; }
   void move_next ()	  { --m_pos; }
 
@@ -82,7 +83,7 @@ private:
   bitmap m_has_cache_entry;
 
   // Path being analyzed.
-  const vec<basic_block> *m_path;
+  auto_vec<basic_block> m_path;
 
   auto_bitmap m_imports;
   gimple_ranger &m_ranger;