sbitmap: Rename bitmap_bit_in_range_p to bitmap_any_bit_in_range_p

This patch renames `bitmap_bit_in_range_p` to
`bitmap_any_bit_in_range_p` to better reflect its purpose.

gcc/ChangeLog:

	* sbitmap.cc (bitmap_bit_in_range_p): Renamed the function.
	(bitmap_any_bit_in_range_p): New function name.
	(bitmap_bit_in_range_p_checking): Renamed the function.
	(bitmap_any_bit_in_range_p_checking): New function name.
	(test_set_range): Updated function calls to use the new name.
	(test_bit_in_range): Likewise.
	* sbitmap.h (bitmap_bit_in_range_p): Renamed the function.
	(bitmap_any_bit_in_range_p): New function name.
	* tree-ssa-dse.cc (live_bytes_read):
	Updated function call to use the new name.

3 files changed, 59 insertions, 57 deletions

diff --git a/gcc/sbitmap.cc b/gcc/sbitmap.cc
index df2e1aa..64c7517 100644
--- a/gcc/sbitmap.cc
+++ b/gcc/sbitmap.cc
@@ -330,7 +330,8 @@ bitmap_set_range (sbitmap bmap, unsigned int start, unsigned int count)
    the simple bitmap BMAP.  Return FALSE otherwise.  */
 
 bool
-bitmap_bit_in_range_p (const_sbitmap bmap, unsigned int start, unsigned int end)
+bitmap_any_bit_in_range_p (const_sbitmap bmap, unsigned int start,
+			   unsigned int end)
 {
   gcc_checking_assert (start <= end);
   bitmap_check_index (bmap, end);
@@ -863,14 +864,14 @@ namespace selftest {
 
 /* Selftests for sbitmaps.  */
 
-/* Checking function that uses both bitmap_bit_in_range_p and
+/* Checking function that uses both bitmap_any_bit_in_range_p and
    loop of bitmap_bit_p and verifies consistent results.  */
 
 static bool
-bitmap_bit_in_range_p_checking (sbitmap s, unsigned int start,
+bitmap_any_bit_in_range_p_checking (sbitmap s, unsigned int start,
 				unsigned end)
 {
-  bool r1 = bitmap_bit_in_range_p (s, start, end);
+  bool r1 = bitmap_any_bit_in_range_p (s, start, end);
   bool r2 = false;
 
   for (unsigned int i = start; i <= end; i++)
@@ -893,33 +894,33 @@ test_set_range ()
   bitmap_clear (s);
 
   bitmap_set_range (s, 0, 1);
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 0, 0));
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 1, 15));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 0, 0));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 1, 15));
   bitmap_set_range (s, 15, 1);
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 1, 14));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 15, 15));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 1, 14));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 15, 15));
   sbitmap_free (s);
 
   s = sbitmap_alloc (1024);
   bitmap_clear (s);
   bitmap_set_range (s, 512, 1);
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 0, 511));
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 513, 1023));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 512, 512));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 508, 512));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 508, 513));
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 508, 511));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 0, 511));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 513, 1023));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 512, 512));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 508, 512));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 508, 513));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 508, 511));
 
   bitmap_clear (s);
   bitmap_set_range (s, 512, 64);
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 0, 511));
-  ASSERT_FALSE (bitmap_bit_in_range_p_checking (s, 512 + 64, 1023));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 512, 512));
-  ASSERT_TRUE (bitmap_bit_in_range_p_checking (s, 512 + 63, 512 + 63));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 0, 511));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p_checking (s, 512 + 64, 1023));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 512, 512));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p_checking (s, 512 + 63, 512 + 63));
   sbitmap_free (s);
 }
 
-/* Verify bitmap_bit_in_range_p functions for sbitmap.  */
+/* Verify bitmap_any_bit_in_range_p functions for sbitmap.  */
 
 static void
 test_bit_in_range ()
@@ -927,15 +928,15 @@ test_bit_in_range ()
   sbitmap s = sbitmap_alloc (1024);
   bitmap_clear (s);
 
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 512, 1023));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 512, 1023));
   bitmap_set_bit (s, 100);
 
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 512, 1023));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 99));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 101, 1023));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 1, 100));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 64, 100));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 100, 100));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 512, 1023));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 99));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 101, 1023));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 1, 100));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 64, 100));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 100, 100));
   ASSERT_TRUE (bitmap_bit_p (s, 100));
 
   sbitmap_free (s);
@@ -943,54 +944,54 @@ test_bit_in_range ()
   s = sbitmap_alloc (64);
   bitmap_clear (s);
   bitmap_set_bit (s, 63);
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 63));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 1, 63));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 63, 63));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 63));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 1, 63));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 63, 63));
   ASSERT_TRUE (bitmap_bit_p (s, 63));
   sbitmap_free (s);
 
   s = sbitmap_alloc (1024);
   bitmap_clear (s);
   bitmap_set_bit (s, 128);
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 127));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 129, 1023));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 127));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 129, 1023));
 
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 128));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 1, 128));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 128, 255));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 128, 254));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 128));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 1, 128));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 128, 255));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 128, 254));
   ASSERT_TRUE (bitmap_bit_p (s, 128));
 
   bitmap_clear (s);
   bitmap_set_bit (s, 8);
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 8));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 12));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 63));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 127));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 512));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 8, 8));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 8));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 12));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 63));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 127));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 512));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 8, 8));
   ASSERT_TRUE (bitmap_bit_p (s, 8));
 
   bitmap_clear (s);
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 0));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 8));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 63));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 1, 63));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 0, 256));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 0));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 8));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 63));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 1, 63));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 0, 256));
 
   bitmap_set_bit (s, 0);
   bitmap_set_bit (s, 16);
   bitmap_set_bit (s, 32);
   bitmap_set_bit (s, 48);
   bitmap_set_bit (s, 64);
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 0, 0));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 1, 16));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 48, 63));
-  ASSERT_TRUE (bitmap_bit_in_range_p (s, 64, 64));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 1, 15));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 17, 31));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 49, 63));
-  ASSERT_FALSE (bitmap_bit_in_range_p (s, 65, 1023));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 0, 0));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 1, 16));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 48, 63));
+  ASSERT_TRUE (bitmap_any_bit_in_range_p (s, 64, 64));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 1, 15));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 17, 31));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 49, 63));
+  ASSERT_FALSE (bitmap_any_bit_in_range_p (s, 65, 1023));
   sbitmap_free (s);
 }
 
diff --git a/gcc/sbitmap.h b/gcc/sbitmap.h
index 66f9e13..927d296 100644
--- a/gcc/sbitmap.h
+++ b/gcc/sbitmap.h
@@ -51,7 +51,7 @@ along with GCC; see the file COPYING3.  If not see
      * set_difference		: bitmap_and_compl
      * set_disjuction		: (not implemented)
      * set_compare		: bitmap_equal_p
-     * bit_in_range_p		: bitmap_bit_in_range_p
+     * any_bit_in_range_p	: bitmap_any_bit_in_range_p
 
    Some operations on 3 sets that occur frequently in data flow problems
    are also implemented:
@@ -287,7 +287,8 @@ extern bool bitmap_and (sbitmap, const_sbitmap, const_sbitmap);
 extern bool bitmap_ior (sbitmap, const_sbitmap, const_sbitmap);
 extern bool bitmap_xor (sbitmap, const_sbitmap, const_sbitmap);
 extern bool bitmap_subset_p (const_sbitmap, const_sbitmap);
-extern bool bitmap_bit_in_range_p (const_sbitmap, unsigned int, unsigned int);
+extern bool bitmap_any_bit_in_range_p (const_sbitmap, unsigned int,
+				       unsigned int);
 
 extern int bitmap_first_set_bit (const_sbitmap);
 extern int bitmap_last_set_bit (const_sbitmap);
diff --git a/gcc/tree-ssa-dse.cc b/gcc/tree-ssa-dse.cc
index d1d58bf..5ac4280 100644
--- a/gcc/tree-ssa-dse.cc
+++ b/gcc/tree-ssa-dse.cc
@@ -842,7 +842,7 @@ live_bytes_read (ao_ref *use_ref, ao_ref *ref, sbitmap live)
 	return true;
 
       /* Now check if any of the remaining bits in use_ref are set in LIVE.  */
-      return bitmap_bit_in_range_p (live, start, (start + size - 1));
+      return bitmap_any_bit_in_range_p (live, start, (start + size - 1));
     }
   return true;
 }