Tweaks to ranger cache

Add some bounds checking to ssa_block_ranges, and privatize the
ranges block cache and global cache, adding API points for accessing them.

	* gimple-range-cache.h (block_range_cache): Add new entry point.
	(ranger_cache): Privatize global abnd block cache members.
	* gimple-range-cache.cc (ssa_block_ranges::set_bb_range): Add bounds
	check.
	(ssa_block_ranges::set_bb_varying): Ditto.
	(ssa_block_ranges::get_bb_range): Ditto.
	(ssa_block_ranges::bb_range_p): Ditto.
	(block_range_cache::get_block_ranges): Fix formatting.
	(block_range_cache::query_block_ranges): New.
	(block_range_cache::get_bb_range): Use Query_block_ranges.
	(block_range_cache::bb_range_p): Ditto.
	(ranger_cache::dump): New.
	(ranger_cache::get_global_range): New.
	(ranger_cache::set_global_range): New.
	* gimple-range.cc (gimple_ranger::range_of_expr): Use new API.
	(gimple_ranger::range_of_stmt): Ditto.
	(gimple_ranger::export_global_ranges): Ditto.
	(gimple_ranger::dump): Ditto.

diff --git a/gcc/gimple-range-cache.cc b/gcc/gimple-range-cache.cc
index bc9243c1279af95059e7e2ee6ea3a67cdcfe4bf9..574debbc166e1b254bee514e755ad27dc4c9a3c5 100644 (file)
--- a/gcc/gimple-range-cache.cc
+++ b/gcc/gimple-range-cache.cc
@@ -165,6 +165,7 @@ ssa_block_ranges::~ssa_block_ranges ()
 void
 ssa_block_ranges::set_bb_range (const basic_block bb, const irange &r)
 {
+  gcc_checking_assert ((unsigned) bb->index < m_tab.length ());
   irange *m = m_irange_allocator->allocate (r);
   m_tab[bb->index] = m;
 }
@@ -174,6 +175,7 @@ ssa_block_ranges::set_bb_range (const basic_block bb, const irange &r)
 void
 ssa_block_ranges::set_bb_varying (const basic_block bb)
 {
+  gcc_checking_assert ((unsigned) bb->index < m_tab.length ());
   m_tab[bb->index] = m_type_range;
 }
 
@@ -183,6 +185,7 @@ ssa_block_ranges::set_bb_varying (const basic_block bb)
 bool
 ssa_block_ranges::get_bb_range (irange &r, const basic_block bb)
 {
+  gcc_checking_assert ((unsigned) bb->index < m_tab.length ());
   irange *m = m_tab[bb->index];
   if (m)
     {
@@ -197,6 +200,7 @@ ssa_block_ranges::get_bb_range (irange &r, const basic_block bb)
 bool
 ssa_block_ranges::bb_range_p (const basic_block bb)
 {
+  gcc_checking_assert ((unsigned) bb->index < m_tab.length ());
   return m_tab[bb->index] != NULL;
 }
 
@@ -244,8 +248,8 @@ block_range_cache::~block_range_cache ()
   m_ssa_ranges.release ();
 }
 
-// Return a reference to the m_block_cache for NAME.  If it has not been
-// accessed yet, allocate it.
+// Return a reference to the ssa_block_cache for NAME.  If it has not been
+// accessed yet, allocate it first.
 
 ssa_block_ranges &
 block_range_cache::get_block_ranges (tree name)
@@ -255,11 +259,24 @@ block_range_cache::get_block_ranges (tree name)
     m_ssa_ranges.safe_grow_cleared (num_ssa_names + 1);
 
   if (!m_ssa_ranges[v])
-    m_ssa_ranges[v] = new ssa_block_ranges (TREE_TYPE (name), m_irange_allocator);
-
+    m_ssa_ranges[v] = new ssa_block_ranges (TREE_TYPE (name),
+                                           m_irange_allocator);
   return *(m_ssa_ranges[v]);
 }
 
+
+// Return a pointer to the ssa_block_cache for NAME.  If it has not been
+// accessed yet, return NULL.
+
+ssa_block_ranges *
+block_range_cache::query_block_ranges (tree name)
+{
+  unsigned v = SSA_NAME_VERSION (name);
+  if (v >= m_ssa_ranges.length () || !m_ssa_ranges[v])
+    return NULL;
+  return m_ssa_ranges[v];
+}
+
 // Set the range for NAME on entry to block BB to R.
 
 void
@@ -283,7 +300,10 @@ block_range_cache::set_bb_varying (tree name, const basic_block bb)
 bool
 block_range_cache::get_bb_range (irange &r, tree name, const basic_block bb)
 {
-  return get_block_ranges (name).get_bb_range (r, bb);
+  ssa_block_ranges *ptr = query_block_ranges (name);
+  if (ptr)
+    return ptr->get_bb_range (r, bb);
+  return false;
 }
 
 // Return true if NAME has a range set in block BB.
@@ -291,7 +311,10 @@ block_range_cache::get_bb_range (irange &r, tree name, const basic_block bb)
 bool
 block_range_cache::bb_range_p (tree name, const basic_block bb)
 {
-  return get_block_ranges (name).bb_range_p (bb);
+  ssa_block_ranges *ptr = query_block_ranges (name);
+  if (ptr)
+    return ptr->bb_range_p (bb);
+  return false;
 }
 
 // Print all known block caches to file F.
@@ -472,6 +495,46 @@ ranger_cache::~ranger_cache ()
   m_update_list.release ();
 }
 
+// Dump the global caches to file F.  if GORI_DUMP is true, dump the
+// gori map as well.
+
+void
+ranger_cache::dump (FILE *f, bool gori_dump)
+{
+  m_globals.dump (f);
+  if (gori_dump)
+    {
+      fprintf (f, "\nDUMPING GORI MAP\n");
+      gori_compute::dump (f);
+    }
+  fprintf (f, "\n");
+}
+
+// Dump the caches for basic block BB to file F.
+
+void
+ranger_cache::dump (FILE *f, basic_block bb)
+{
+  m_on_entry.dump (f, bb);
+}
+
+// Get the global range for NAME, and return in R.  Return false if the
+// global range is not set.
+
+bool
+ranger_cache::get_global_range (irange &r, tree name) const
+{
+  return m_globals.get_global_range (r, name);
+}
+
+//  Set the global range of NAME to R.
+
+void
+ranger_cache::set_global_range (tree name, const irange &r)
+{
+  m_globals.set_global_range (name, r);
+}
+
 // Push a request for a new lookup in block BB of name.  Return true if
 // the request is actually made (ie, isn't a duplicate).
 
@@ -869,5 +932,4 @@ ranger_cache::fill_block_cache (tree name, basic_block bb, basic_block def_bb)
          iterative_cache_update (name);
        }
     }
- 
 }

diff --git a/gcc/gimple-range-cache.h b/gcc/gimple-range-cache.h
index 29ab01e2a984d560b6198beeed89eaeac5202e2b..599a2926b53598251ac4d95a7ca621e513264f9f 100644 (file)
--- a/gcc/gimple-range-cache.h
+++ b/gcc/gimple-range-cache.h
@@ -60,6 +60,7 @@ public:
 private:
   vec<class ssa_block_ranges *> m_ssa_ranges;
   ssa_block_ranges &get_block_ranges (tree name);
+  ssa_block_ranges *query_block_ranges (tree name);
   irange_allocator *m_irange_allocator;
 };
 
@@ -95,10 +96,16 @@ public:
   virtual void ssa_range_in_bb (irange &r, tree name, basic_block bb);
   bool block_range (irange &r, basic_block bb, tree name, bool calc = true);
 
-  ssa_global_cache m_globals;
-  block_range_cache m_on_entry;
+  bool get_global_range (irange &r, tree name) const;
+  void set_global_range (tree name, const irange &r);
+
   non_null_ref m_non_null;
+
+  void dump (FILE *f, bool dump_gori = true);
+  void dump (FILE *f, basic_block bb);
 private:
+  ssa_global_cache m_globals;
+  block_range_cache m_on_entry;
   void add_to_update (basic_block bb);
   void fill_block_cache (tree name, basic_block bb, basic_block def_bb);
   void iterative_cache_update (tree name);

diff --git a/gcc/gimple-range.cc b/gcc/gimple-range.cc
index cf979845acffad6c6e71d187e18ce1ade34d1b1e..8fdcc310111448b833824f90eed937ebf39ea29b 100644 (file)
--- a/gcc/gimple-range.cc
+++ b/gcc/gimple-range.cc
@@ -897,7 +897,7 @@ gimple_ranger::range_of_expr (irange &r, tree expr, gimple *stmt)
   // If there is no statement, just get the global value.
   if (!stmt)
     {
-      if (!m_cache.m_globals.get_global_range (r, expr))
+      if (!m_cache.get_global_range (r, expr))
         r = gimple_range_global (expr);
       return true;
     }
@@ -1010,18 +1010,18 @@ gimple_ranger::range_of_stmt (irange &r, gimple *s, tree name)
     return false;
 
   // If this STMT has already been processed, return that value.
-  if (m_cache.m_globals.get_global_range (r, name))
+  if (m_cache.get_global_range (r, name))
     return true;
 
   // Avoid infinite recursion by initializing global cache
   int_range_max tmp = gimple_range_global (name);
-  m_cache.m_globals.set_global_range (name, tmp);
+  m_cache.set_global_range (name, tmp);
 
   calc_stmt (r, s, name);
 
   if (is_a<gphi *> (s))
     r.intersect (tmp);
-  m_cache.m_globals.set_global_range (name, r);
+  m_cache.set_global_range (name, r);
   return true;
 }
 
@@ -1044,7 +1044,7 @@ gimple_ranger::export_global_ranges ()
       tree name = ssa_name (x);
       if (name && !SSA_NAME_IN_FREE_LIST (name)
          && gimple_range_ssa_p (name)
-         && m_cache.m_globals.get_global_range (r, name)
+         && m_cache.get_global_range (r, name)
          && !r.varying_p())
        {
          // Make sure the new range is a subset of the old range.
@@ -1088,7 +1088,7 @@ gimple_ranger::dump (FILE *f)
       edge e;
       int_range_max range;
       fprintf (f, "\n=========== BB %d ============\n", bb->index);
-      m_cache.m_on_entry.dump (f, bb);
+      m_cache.dump (f, bb);
 
       dump_bb (f, bb, 4, TDF_NONE);
 
@@ -1098,7 +1098,7 @@ gimple_ranger::dump (FILE *f)
          tree name = ssa_name (x);
          if (gimple_range_ssa_p (name) && SSA_NAME_DEF_STMT (name) &&
              gimple_bb (SSA_NAME_DEF_STMT (name)) == bb &&
-             m_cache.m_globals.get_global_range (range, name))
+             m_cache.get_global_range (range, name))
            {
              if (!range.varying_p ())
               {
@@ -1150,15 +1150,7 @@ gimple_ranger::dump (FILE *f)
        }
     }
 
-  m_cache.m_globals.dump (dump_file);
-  fprintf (f, "\n");
-
-  if (dump_flags & TDF_DETAILS)
-    {
-      fprintf (f, "\nDUMPING GORI MAP\n");
-      m_cache.dump (f);
-      fprintf (f, "\n");
-    }
+  m_cache.dump (dump_file, (dump_flags & TDF_DETAILS) != 0);
 }
 
 // If SCEV has any information about phi node NAME, return it as a range in R.