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.
Signed-off-by: Konstantinos Eleftheriou <konstantinos.elefther...@vrull.eu>
---
(no changes since v1)
gcc/sbitmap.cc | 109 ++++++++++++++++++++++----------------------
gcc/sbitmap.h | 5 +-
gcc/tree-ssa-dse.cc | 2 +-
3 files changed, 59 insertions(+), 57 deletions(-)
diff --git a/gcc/sbitmap.cc b/gcc/sbitmap.cc
index df2e1aa49358..64c7517397b3 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 66f9e138503c..927d296f4606 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 d1d58bf2bb35..5ac4280ee361 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;
}
--
2.49.0
