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 --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 99ac947581becd5ffc42d2ac3d377469cb8327fc..6da01c7067f533ecaa1836d707fbc32bc07ce3bc 100644 (file)
--- 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 f21d07f71c444f22aa342ef5a096b818a282399a..b73549f01a5e93c0160587a09e80e80db127c439 100644 (file)
--- 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;