Make gori_map a shared component.

Move gori_map dependency and import/export object into a range query and
construct it simultaneously with a gori object.

	* gimple-range-cache.cc (ranger_cache::ranger_cache): Use gori_ssa.
	(ranger_cache::dump): Likewise.
	(ranger_cache::get_global_range): Likewise.
	(ranger_cache::set_global_range): Likewise.
	(ranger_cache::register_inferred_value): Likewise.
	* gimple-range-edge.h (gimple_outgoing_range::map): Remove.
	* gimple-range-fold.cc (fold_using_range::range_of_range_op): Use
	gori_ssa.
	(fold_using_range::range_of_address): Likewise.
	(fold_using_range::range_of_phi): Likewise.
	(fur_source::register_outgoing_edges): Likewise.
	* gimple-range-fold.h (fur_source::query): Make const.
	(gori_ssa): New.
	* gimple-range-gori.cc (gori_map::dump): Use 'this' pointer.
	(gori_compute::gori_compute): Construct with a gori_map.
	* gimple-range-gori.h (gori_compute:gori_compute): Change
	prototype.
	(gori_compute::map): Delete.
	(gori_compute::m_map): Change to a reference.
	(FOR_EACH_GORI_IMPORT_NAME): Change parameter gori to gorimap.
	(FOR_EACH_GORI_EXPORT_NAME): Likewise.
	* gimple-range-path.cc (path_range_query::compute_ranges_in_block):
	Use gori_ssa method.
	(path_range_query::compute_exit_dependencies): Likewise.
	* gimple-range.cc (gimple_ranger::range_of_stmt): Likewise.
	(gimple_ranger::register_transitive_inferred_ranges): Likewise.
	* tree-ssa-dom.cc (set_global_ranges_from_unreachable_edges):
	Likewise.
	* tree-ssa-threadedge.cc (compute_exit_dependencies): Likewise.
	* tree-vrp.cc (remove_unreachable::handle_early): Likewise.
	(remove_unreachable::remove_and_update_globals): Likewise.
	* value-query.cc (range_query::create_gori): Create gori map.
	(range_query::share_query): Copy gori map member.
	(range_query::range_query): Initiialize gori_map member.
	* value-query.h (range_query::gori_ssa): New.
	(range_query::m_map): New.

13 files changed, 53 insertions, 45 deletions

diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index e75cac6..a511a2c 100644
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -969,7 +969,7 @@ ranger_cache::ranger_cache (int not_executable_flag, bool use_imm_uses)
     {
       basic_block bb = BASIC_BLOCK_FOR_FN (cfun, x);
       if (bb)
-	gori ().map ()->exports (bb);
+	gori_ssa ()->exports (bb);
     }
   m_update = new update_list ();
 }
@@ -1000,7 +1000,7 @@ ranger_cache::dump (FILE *f)
 void
 ranger_cache::dump_bb (FILE *f, basic_block bb)
 {
-  gori ().map ()->dump (f, bb, false);
+  gori_ssa ()->dump (f, bb, false);
   m_on_entry.dump (f, bb);
   m_relation->dump (f, bb);
 }
@@ -1033,8 +1033,8 @@ ranger_cache::get_global_range (vrange &r, tree name, bool &current_p)
   current_p = false;
   if (had_global)
     current_p = r.singleton_p ()
-		|| m_temporal->current_p (name, gori ().map ()->depend1 (name),
-					  gori ().map ()->depend2 (name));
+		|| m_temporal->current_p (name, gori_ssa ()->depend1 (name),
+					  gori_ssa ()->depend2 (name));
   else
     {
       // If no global value has been set and value is VARYING, fold the stmt
@@ -1071,8 +1071,8 @@ ranger_cache::set_global_range (tree name, const vrange &r, bool changed)
   if (!changed)
     {
       // If there are dependencies, make sure this is not out of date.
-      if (!m_temporal->current_p (name, gori ().map ()->depend1 (name),
-				 gori ().map ()->depend2 (name)))
+      if (!m_temporal->current_p (name, gori_ssa ()->depend1 (name),
+				 gori_ssa ()->depend2 (name)))
 	m_temporal->set_timestamp (name);
       return;
     }
@@ -1097,7 +1097,7 @@ ranger_cache::set_global_range (tree name, const vrange &r, bool changed)
 
   if (r.singleton_p ()
       || (POINTER_TYPE_P (TREE_TYPE (name)) && r.nonzero_p ()))
-    gori ().map ()->set_range_invariant (name);
+    gori_ssa ()->set_range_invariant (name);
   m_temporal->set_timestamp (name);
 }
 
@@ -1783,7 +1783,7 @@ ranger_cache::register_inferred_value (const vrange &ir, tree name,
       m_on_entry.set_bb_range (name, bb, r);
       // If this range was invariant before, remove invariant.
       if (!gori ().has_edge_range_p (name))
-	gori ().map ()->set_range_invariant (name, false);
+	gori_ssa ()->set_range_invariant (name, false);
     }
 }
 
diff --git a/gcc/gimple-range-edge.h b/gcc/gimple-range-edge.h
index be1f0c2..0096c02 100644
--- a/gcc/gimple-range-edge.h
+++ b/gcc/gimple-range-edge.h
@@ -63,7 +63,6 @@ public:
 				      fur_source &,
 				      class value_relation * = NULL)
     { return false; }
-  virtual class gori_map *map () { return NULL; }
 private:
   void calc_switch_ranges (gswitch *sw);
   bool switch_edge_range (irange &r, gswitch *sw, edge e);
diff --git a/gcc/gimple-range-fold.cc b/gcc/gimple-range-fold.cc
index e9e387c..a0ff7f2 100644
--- a/gcc/gimple-range-fold.cc
+++ b/gcc/gimple-range-fold.cc
@@ -745,8 +745,8 @@ fold_using_range::range_of_range_op (vrange &r,
 	    r.set_varying (type);
 	  if (lhs && gimple_range_ssa_p (op1))
 	    {
-	      if (src.gori ())
-		src.gori ()->map ()->register_dependency (lhs, op1);
+	      if (src.gori_bb ())
+		src.gori_bb ()->register_dependency (lhs, op1);
 	      relation_kind rel;
 	      rel = handler.lhs_op1_relation (r, range1, range1);
 	      if (rel != VREL_VARYING)
@@ -772,10 +772,10 @@ fold_using_range::range_of_range_op (vrange &r,
 	    relation_fold_and_or (as_a <irange> (r), s, src, range1, range2);
 	  if (lhs)
 	    {
-	      if (src.gori ())
+	      if (src.gori_bb ())
 		{
-		  src.gori ()->map ()->register_dependency (lhs, op1);
-		  src.gori ()->map ()->register_dependency (lhs, op2);
+		  src.gori_bb ()->register_dependency (lhs, op1);
+		  src.gori_bb ()->register_dependency (lhs, op2);
 		}
 	      if (gimple_range_ssa_p (op1))
 		{
@@ -843,8 +843,8 @@ fold_using_range::range_of_address (prange &r, gimple *stmt, fur_source &src)
     {
       tree ssa = TREE_OPERAND (base, 0);
       tree lhs = gimple_get_lhs (stmt);
-      if (lhs && gimple_range_ssa_p (ssa) && src.gori ())
-	src.gori ()->map ()->register_dependency (lhs, ssa);
+      if (lhs && gimple_range_ssa_p (ssa) && src.gori_bb ())
+	src.gori_bb ()->register_dependency (lhs, ssa);
       src.get_operand (r, ssa);
       range_cast (r, TREE_TYPE (gimple_assign_rhs1 (stmt)));
 
@@ -950,8 +950,8 @@ fold_using_range::range_of_phi (vrange &r, gphi *phi, fur_source &src)
 	  else
 	    r.union_ (arg_range);
 
-	  if (gimple_range_ssa_p (arg) && src.gori ())
-	    src.gori ()->map ()->register_dependency (phi_def, arg);
+	  if (gimple_range_ssa_p (arg) && src.gori_bb ())
+	    src.gori_bb ()->register_dependency (phi_def, arg);
 	}
 
       // Track if all arguments are the same.
@@ -1345,14 +1345,14 @@ fur_source::register_outgoing_edges (gcond *s, irange &lhs_range,
     }
 
   // Outgoing relations of GORI exports require a gori engine.
-  if (!gori ())
+  if (!gori_bb ())
     return;
 
   // Now look for other relations in the exports.  This will find stmts
   // leading to the condition such as:
   // c_2 = a_4 < b_7
   // if (c_2)
-  FOR_EACH_GORI_EXPORT_NAME (*(gori ()->map ()), bb, name)
+  FOR_EACH_GORI_EXPORT_NAME (gori_bb (), bb, name)
     {
       if (TREE_CODE (TREE_TYPE (name)) != BOOLEAN_TYPE)
 	continue;
diff --git a/gcc/gimple-range-fold.h b/gcc/gimple-range-fold.h
index 9ae6cf5..b240a6e 100644
--- a/gcc/gimple-range-fold.h
+++ b/gcc/gimple-range-fold.h
@@ -105,7 +105,9 @@ class fur_source
 {
 public:
   fur_source (range_query *q = NULL);
-  inline range_query *query () { return m_query; }
+  inline range_query *query () const { return m_query; }
+  inline gori_map *gori_bb () const
+    { return (m_depend_p && m_query) ? m_query->gori_ssa () : NULL; }
   inline class gimple_outgoing_range *gori ()
     { return m_depend_p ? &(m_query->gori ()) : NULL; }
   virtual bool get_operand (vrange &r, tree expr);
diff --git a/gcc/gimple-range-gori.cc b/gcc/gimple-range-gori.cc
index a754306..a3fe67e 100644
--- a/gcc/gimple-range-gori.cc
+++ b/gcc/gimple-range-gori.cc
@@ -514,7 +514,7 @@ gori_map::dump (FILE *f, basic_block bb, bool verbose)
 	fprintf (f, "bb<%u> Imports: ",bb->index);
       else
 	fprintf (f, "Imports: ");
-      FOR_EACH_GORI_IMPORT_NAME (*this, bb, name)
+      FOR_EACH_GORI_IMPORT_NAME (this, bb, name)
 	{
 	  print_generic_expr (f, name, TDF_SLIM);
 	  fprintf (f, "  ");
@@ -527,7 +527,7 @@ gori_map::dump (FILE *f, basic_block bb, bool verbose)
   else
     fprintf (f, "Exports: ");
   // Dump the export vector.
-  FOR_EACH_GORI_EXPORT_NAME (*this, bb, name)
+  FOR_EACH_GORI_EXPORT_NAME (this, bb, name)
     {
       print_generic_expr (f, name, TDF_SLIM);
       fprintf (f, "  ");
@@ -557,8 +557,9 @@ debug (gori_map &g)
 
 // Construct a gori_compute object.
 
-gori_compute::gori_compute (int not_executable_flag, int sw_max_edges)
-  : gimple_outgoing_range (sw_max_edges), tracer ("GORI ")
+gori_compute::gori_compute (gori_map &map, int not_executable_flag,
+			    int sw_max_edges)
+  : gimple_outgoing_range (sw_max_edges), m_map (map), tracer ("GORI ")
 {
   m_not_executable_flag = not_executable_flag;
   // Create a boolean_type true and false range.
diff --git a/gcc/gimple-range-gori.h b/gcc/gimple-range-gori.h
index c7a707e..aa8369a 100644
--- a/gcc/gimple-range-gori.h
+++ b/gcc/gimple-range-gori.h
@@ -164,7 +164,8 @@ class value_relation;
 class gori_compute : public gimple_outgoing_range
 {
 public:
-  gori_compute (int not_executable_flag = 0, int max_sw_edges = 0);
+  gori_compute (gori_map &map, int not_executable_flag = 0,
+		int max_sw_edges = 0);
   virtual ~gori_compute ();
   bool edge_range_p (vrange &r, edge e, tree name, range_query &q);
   bool condexpr_adjust (vrange &r1, vrange &r2, gimple *s, tree cond, tree op1,
@@ -175,9 +176,8 @@ public:
   bool compute_operand_range (vrange &r, gimple *stmt, const vrange &lhs,
 			      tree name, class fur_source &src,
 			      value_relation *rel = NULL);
-  gori_map *map () { return &m_map; }
 private:
-  gori_map m_map;
+  gori_map &m_map;
   bool refine_using_relation (tree op1, vrange &op1_range,
 			      tree op2, vrange &op2_range,
 			      fur_source &src, relation_kind k);
@@ -226,14 +226,14 @@ bool gori_on_edge (class ssa_cache &r, edge e,
 bool gori_name_on_edge (vrange &r, tree name, edge e, range_query *q = NULL);
 
 // For each name that is an import into BB's exports..
-#define FOR_EACH_GORI_IMPORT_NAME(gori, bb, name)			\
-  for (gori_export_iterator iter ((gori).imports ((bb)));	\
+#define FOR_EACH_GORI_IMPORT_NAME(gorimap, bb, name)			\
+  for (gori_export_iterator iter ((gorimap)->imports ((bb)));	\
        ((name) = iter.get_name ());				\
        iter.next ())
 
 // For each name possibly exported from block BB.
-#define FOR_EACH_GORI_EXPORT_NAME(gori, bb, name)		\
-  for (gori_export_iterator iter ((gori).exports ((bb)));	\
+#define FOR_EACH_GORI_EXPORT_NAME(gorimap, bb, name)		\
+  for (gori_export_iterator iter ((gorimap)->exports ((bb)));	\
        ((name) = iter.get_name ());				\
        iter.next ())
 
diff --git a/gcc/gimple-range-path.cc b/gcc/gimple-range-path.cc
index 707bd0e..ef125a9 100644
--- a/gcc/gimple-range-path.cc
+++ b/gcc/gimple-range-path.cc
@@ -413,7 +413,7 @@ path_range_query::compute_ranges_in_block (basic_block bb)
       p->reset_path ();
     }
 
-  bitmap exports = gori ().map ()->exports (bb);
+  bitmap exports = gori_ssa ()->exports (bb);
   EXECUTE_IF_AND_IN_BITMAP (m_exit_dependencies, exports, 0, i, bi)
     {
       tree name = ssa_name (i);
@@ -490,7 +490,7 @@ path_range_query::compute_exit_dependencies (bitmap dependencies)
 {
   // Start with the imports from the exit block...
   basic_block exit = m_path[0];
-  bitmap_copy (dependencies, gori ().map()->imports (exit));
+  bitmap_copy (dependencies, gori_ssa ()->imports (exit));
 
   auto_vec<tree> worklist (bitmap_count_bits (dependencies));
   bitmap_iterator bi;
@@ -538,7 +538,7 @@ path_range_query::compute_exit_dependencies (bitmap dependencies)
       {
 	basic_block bb = m_path[i];
 	tree name;
-	FOR_EACH_GORI_EXPORT_NAME (*(gori ().map ()), bb, name)
+	FOR_EACH_GORI_EXPORT_NAME (gori_ssa (), bb, name)
 	  if (TREE_CODE (TREE_TYPE (name)) == BOOLEAN_TYPE)
 	    bitmap_set_bit (dependencies, SSA_NAME_VERSION (name));
       }
diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc
index 2029461..0749c9fa 100644
--- a/gcc/gimple-range.cc
+++ b/gcc/gimple-range.cc
@@ -310,7 +310,7 @@ gimple_ranger::range_of_stmt (vrange &r, gimple *s, tree name)
 	  // Update any exports in the cache if this is a gimple cond statement.
 	  tree exp;
 	  basic_block bb = gimple_bb (s);
-	  FOR_EACH_GORI_EXPORT_NAME (*(gori ().map ()), bb, exp)
+	  FOR_EACH_GORI_EXPORT_NAME (gori_ssa (), bb, exp)
 	    m_cache.propagate_updated_value (exp, bb);
 	}
     }
@@ -540,8 +540,8 @@ gimple_ranger::register_transitive_inferred_ranges (basic_block bb)
       // an inferred range as well.
       Value_Range r (TREE_TYPE (lhs));
       r.set_undefined ();
-      tree name1 = gori ().map () ->depend1 (lhs);
-      tree name2 = gori ().map ()->depend2 (lhs);
+      tree name1 = gori_ssa ()->depend1 (lhs);
+      tree name2 = gori_ssa ()->depend2 (lhs);
       if ((name1 && infer_oracle ().has_range_p (bb, name1))
 	  || (name2 && infer_oracle ().has_range_p (bb, name2)))
 	{
diff --git a/gcc/tree-ssa-dom.cc b/gcc/tree-ssa-dom.cc
index 67c87bb..800bc5a 100644
--- a/gcc/tree-ssa-dom.cc
+++ b/gcc/tree-ssa-dom.cc
@@ -1430,7 +1430,7 @@ dom_opt_dom_walker::set_global_ranges_from_unreachable_edges (basic_block bb)
     return;
 
   tree name;
-  FOR_EACH_GORI_EXPORT_NAME (*(m_ranger->gori ().map()), pred_e->src, name)
+  FOR_EACH_GORI_EXPORT_NAME (m_ranger->gori_ssa (), pred_e->src, name)
     if (all_uses_feed_or_dominated_by_stmt (name, stmt)
 	// The condition must post-dominate the definition point.
 	&& (SSA_NAME_IS_DEFAULT_DEF (name)
diff --git a/gcc/tree-ssa-threadedge.cc b/gcc/tree-ssa-threadedge.cc
index 766b68a..70f269e 100644
--- a/gcc/tree-ssa-threadedge.cc
+++ b/gcc/tree-ssa-threadedge.cc
@@ -1447,7 +1447,7 @@ hybrid_jt_simplifier::compute_exit_dependencies (bitmap dependencies,
 						 gimple *stmt)
 {
   // Start with the imports to the final conditional.
-  bitmap_copy (dependencies, m_ranger->gori ().map ()->imports (path[0]));
+  bitmap_copy (dependencies, m_ranger->gori_ssa ()->imports (path[0]));
 
   // Add any other interesting operands we may have missed.
   if (gimple_bb (stmt) != path[0])
diff --git a/gcc/tree-vrp.cc b/gcc/tree-vrp.cc
index be9df39..7d7f9fe 100644
--- a/gcc/tree-vrp.cc
+++ b/gcc/tree-vrp.cc
@@ -210,14 +210,14 @@ remove_unreachable::handle_early (gimple *s, edge e)
 
   // Check if every export use is dominated by this branch.
   tree name;
-  FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
+  FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori_ssa (), e->src, name)
     {
       if (!fully_replaceable (name, e->src))
 	return;
     }
 
   // Set the global value for each.
-  FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
+  FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori_ssa (), e->src, name)
     {
       Value_Range r (TREE_TYPE (name));
       m_ranger.range_on_entry (r, e->dest, name);
@@ -287,7 +287,7 @@ remove_unreachable::remove_and_update_globals ()
       gcc_checking_assert (gimple_code (s) == GIMPLE_COND);
 
       bool dominate_exit_p = true;
-      FOR_EACH_GORI_EXPORT_NAME (*(m_ranger.gori ().map ()), e->src, name)
+      FOR_EACH_GORI_EXPORT_NAME (m_ranger.gori_ssa (), e->src, name)
 	{
 	  // Ensure the cache is set for NAME in the succ block.
 	  Value_Range r(TREE_TYPE (name));
@@ -305,7 +305,7 @@ remove_unreachable::remove_and_update_globals ()
       // isn't the final VRP pass, leave the call in the IL.
       if (dominate_exit_p)
 	bitmap_ior_into (all_exports,
-			 m_ranger.gori ().map ()->exports (e->src));
+			 m_ranger.gori_ssa ()->exports (e->src));
       else if (!final_p)
 	continue;
 
diff --git a/gcc/value-query.cc b/gcc/value-query.cc
index db813ad..0d0c0e8 100644
--- a/gcc/value-query.cc
+++ b/gcc/value-query.cc
@@ -188,7 +188,9 @@ void
 range_query::create_gori (int not_executable_flag, int sw_max_edges)
 {
   gcc_checking_assert (m_gori == &default_gori);
-  m_gori = new gori_compute (not_executable_flag, sw_max_edges);
+  m_map = new gori_map ();
+  gcc_checking_assert (m_map);
+  m_gori = new gori_compute (*m_map, not_executable_flag, sw_max_edges);
   gcc_checking_assert (m_gori);
 }
 
@@ -251,6 +253,7 @@ range_query::share_query (range_query &q)
   m_relation = q.m_relation;
   m_infer = q.m_infer;
   m_gori = q.m_gori;
+  m_map = q.m_map;
   m_shared_copy_p = true;
 }
 
@@ -259,6 +262,7 @@ range_query::range_query ()
   m_relation = &default_relation_oracle;
   m_infer = &default_infer_oracle;
   m_gori = &default_gori;
+  m_map = NULL;
   m_shared_copy_p = false;
 }
 
diff --git a/gcc/value-query.h b/gcc/value-query.h
index 1481f53..2572a03 100644
--- a/gcc/value-query.h
+++ b/gcc/value-query.h
@@ -84,6 +84,7 @@ public:
   void destroy_infer_oracle ();
 
   inline class gimple_outgoing_range &gori () const { return *m_gori; }
+  inline class gori_map *gori_ssa () const { return m_map; }
   void create_gori (int not_executable_flag = 0, int sw_max_edges = INT_MAX);
   void destroy_gori ();
 
@@ -98,6 +99,7 @@ protected:
   relation_oracle *m_relation;
   infer_range_oracle *m_infer;
   gimple_outgoing_range *m_gori;
+  gori_map *m_map;
   // When multiple related range queries wish to share oracles.
   // This is an internal interface
   void share_query (range_query &q);