322 lines
10 KiB
C++
322 lines
10 KiB
C++
/* Simple bitmaps.
|
|
Copyright (C) 1999-2023 Free Software Foundation, Inc.
|
|
|
|
This file is part of GCC.
|
|
|
|
GCC is free software; you can redistribute it and/or modify it under
|
|
the terms of the GNU General Public License as published by the Free
|
|
Software Foundation; either version 3, or (at your option) any later
|
|
version.
|
|
|
|
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
|
|
WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GCC; see the file COPYING3. If not see
|
|
<http://www.gnu.org/licenses/>. */
|
|
|
|
#ifndef GCC_SBITMAP_H
|
|
#define GCC_SBITMAP_H
|
|
|
|
/* Implementation of sets using simple bitmap vectors.
|
|
|
|
This set representation is suitable for non-sparse sets with a known
|
|
(a priori) universe. The set is represented as a simple array of the
|
|
host's fastest unsigned integer. For a given member I in the set:
|
|
- the element for I will be at sbitmap[I / (bits per element)]
|
|
- the position for I within element is I % (bits per element)
|
|
|
|
This representation is very space-efficient for large non-sparse sets
|
|
with random access patterns.
|
|
|
|
The following operations can be performed in O(1) time:
|
|
|
|
* set_size : SBITMAP_SIZE
|
|
* member_p : bitmap_bit_p
|
|
* add_member : bitmap_set_bit
|
|
* remove_member : bitmap_clear_bit
|
|
|
|
Most other operations on this set representation are O(U) where U is
|
|
the size of the set universe:
|
|
|
|
* clear : bitmap_clear
|
|
* choose_one : bitmap_first_set_bit /
|
|
bitmap_last_set_bit
|
|
* forall : EXECUTE_IF_SET_IN_BITMAP
|
|
* set_copy : bitmap_copy
|
|
* set_intersection : bitmap_and
|
|
* set_union : bitmap_ior
|
|
* set_difference : bitmap_and_compl
|
|
* set_disjuction : (not implemented)
|
|
* set_compare : bitmap_equal_p
|
|
* bit_in_range_p : bitmap_bit_in_range_p
|
|
|
|
Some operations on 3 sets that occur frequently in data flow problems
|
|
are also implemented:
|
|
|
|
* A | (B & C) : bitmap_or_and
|
|
* A | (B & ~C) : bitmap_ior_and_compl
|
|
* A & (B | C) : bitmap_and_or
|
|
|
|
Most of the set functions have two variants: One that returns non-zero
|
|
if members were added or removed from the target set, and one that just
|
|
performs the operation without feedback. The former operations are a
|
|
bit more expensive but the result can often be used to avoid iterations
|
|
on other sets.
|
|
|
|
Allocating a bitmap is done with sbitmap_alloc, and resizing is
|
|
performed with sbitmap_resize.
|
|
|
|
The storage requirements for simple bitmap sets is O(U) where U is the
|
|
size of the set universe (colloquially the number of bits in the bitmap).
|
|
|
|
This set representation works well for relatively small data flow problems
|
|
(there are special routines for that, see sbitmap_vector_*). The set
|
|
operations can be vectorized and there is almost no computating overhead,
|
|
so that even sparse simple bitmap sets outperform dedicated sparse set
|
|
representations like linked-list bitmaps. For larger problems, the size
|
|
overhead of simple bitmap sets gets too high and other set representations
|
|
have to be used. */
|
|
|
|
#define SBITMAP_ELT_BITS (HOST_BITS_PER_WIDEST_FAST_INT * 1u)
|
|
#define SBITMAP_ELT_TYPE unsigned HOST_WIDEST_FAST_INT
|
|
|
|
struct simple_bitmap_def
|
|
{
|
|
unsigned int n_bits; /* Number of bits. */
|
|
unsigned int size; /* Size in elements. */
|
|
SBITMAP_ELT_TYPE elms[1]; /* The elements. */
|
|
};
|
|
|
|
/* Return the set size needed for N elements. */
|
|
#define SBITMAP_SET_SIZE(N) (((N) + SBITMAP_ELT_BITS - 1) / SBITMAP_ELT_BITS)
|
|
|
|
/* Return the number of bits in BITMAP. */
|
|
#define SBITMAP_SIZE(BITMAP) ((BITMAP)->n_bits)
|
|
|
|
/* Verify that access at INDEX in bitmap MAP is valid. */
|
|
|
|
inline void
|
|
bitmap_check_index (const_sbitmap map, int index)
|
|
{
|
|
gcc_checking_assert (index >= 0);
|
|
gcc_checking_assert ((unsigned int)index < map->n_bits);
|
|
}
|
|
|
|
/* Verify that bitmaps A and B have same size. */
|
|
|
|
inline void
|
|
bitmap_check_sizes (const_sbitmap a, const_sbitmap b)
|
|
{
|
|
gcc_checking_assert (a->n_bits == b->n_bits);
|
|
}
|
|
|
|
/* Test if bit number bitno in the bitmap is set. */
|
|
inline bool
|
|
bitmap_bit_p (const_sbitmap map, int bitno)
|
|
{
|
|
bitmap_check_index (map, bitno);
|
|
|
|
size_t i = bitno / SBITMAP_ELT_BITS;
|
|
unsigned int s = bitno % SBITMAP_ELT_BITS;
|
|
return (map->elms[i] >> s) & (SBITMAP_ELT_TYPE) 1;
|
|
}
|
|
|
|
/* Set bit number BITNO in the sbitmap MAP.
|
|
Return true if the bit changed. */
|
|
|
|
inline bool
|
|
bitmap_set_bit (sbitmap map, int bitno)
|
|
{
|
|
bitmap_check_index (map, bitno);
|
|
|
|
size_t i = bitno / SBITMAP_ELT_BITS;
|
|
unsigned int s = bitno % SBITMAP_ELT_BITS;
|
|
if (map->elms[i] & ((SBITMAP_ELT_TYPE) 1 << s))
|
|
return false;
|
|
map->elms[i] |= (SBITMAP_ELT_TYPE) 1 << s;
|
|
return true;
|
|
}
|
|
|
|
/* Reset bit number BITNO in the sbitmap MAP.
|
|
Return true if the bit changed. */
|
|
|
|
inline bool
|
|
bitmap_clear_bit (sbitmap map, int bitno)
|
|
{
|
|
bitmap_check_index (map, bitno);
|
|
|
|
size_t i = bitno / SBITMAP_ELT_BITS;
|
|
unsigned int s = bitno % SBITMAP_ELT_BITS;
|
|
if (!(map->elms[i] & ((SBITMAP_ELT_TYPE) 1 << s)))
|
|
return false;
|
|
map->elms[i] &= ~((SBITMAP_ELT_TYPE) 1 << s);
|
|
return true;
|
|
}
|
|
|
|
/* The iterator for sbitmap. */
|
|
struct sbitmap_iterator {
|
|
/* The pointer to the first word of the bitmap. */
|
|
const SBITMAP_ELT_TYPE *ptr;
|
|
|
|
/* The size of the bitmap. */
|
|
unsigned int size;
|
|
|
|
/* The current word index. */
|
|
unsigned int word_num;
|
|
|
|
/* The current bit index (not modulo SBITMAP_ELT_BITS). */
|
|
unsigned int bit_num;
|
|
|
|
/* The words currently visited. */
|
|
SBITMAP_ELT_TYPE word;
|
|
};
|
|
|
|
/* Initialize the iterator I with sbitmap BMP and the initial index
|
|
MIN. */
|
|
|
|
inline void
|
|
bmp_iter_set_init (sbitmap_iterator *i, const_sbitmap bmp,
|
|
unsigned int min, unsigned *bit_no ATTRIBUTE_UNUSED)
|
|
{
|
|
i->word_num = min / (unsigned int) SBITMAP_ELT_BITS;
|
|
i->bit_num = min;
|
|
i->size = bmp->size;
|
|
i->ptr = bmp->elms;
|
|
|
|
if (i->word_num >= i->size)
|
|
i->word = 0;
|
|
else
|
|
i->word = (i->ptr[i->word_num]
|
|
>> (i->bit_num % (unsigned int) SBITMAP_ELT_BITS));
|
|
}
|
|
|
|
/* Return true if we have more bits to visit, in which case *N is set
|
|
to the index of the bit to be visited. Otherwise, return
|
|
false. */
|
|
|
|
inline bool
|
|
bmp_iter_set (sbitmap_iterator *i, unsigned int *n)
|
|
{
|
|
/* Skip words that are zeros. */
|
|
for (; i->word == 0; i->word = i->ptr[i->word_num])
|
|
{
|
|
i->word_num++;
|
|
|
|
/* If we have reached the end, break. */
|
|
if (i->word_num >= i->size)
|
|
return false;
|
|
|
|
i->bit_num = i->word_num * SBITMAP_ELT_BITS;
|
|
}
|
|
|
|
/* Skip bits that are zero. */
|
|
for (; (i->word & 1) == 0; i->word >>= 1)
|
|
i->bit_num++;
|
|
|
|
*n = i->bit_num;
|
|
|
|
return true;
|
|
}
|
|
|
|
/* Advance to the next bit. */
|
|
|
|
inline void
|
|
bmp_iter_next (sbitmap_iterator *i, unsigned *bit_no ATTRIBUTE_UNUSED)
|
|
{
|
|
i->word >>= 1;
|
|
i->bit_num++;
|
|
}
|
|
|
|
/* Loop over all elements of SBITMAP, starting with MIN. In each
|
|
iteration, N is set to the index of the bit being visited. ITER is
|
|
an instance of sbitmap_iterator used to iterate the bitmap. */
|
|
|
|
#ifndef EXECUTE_IF_SET_IN_BITMAP
|
|
/* See bitmap.h for the other definition of EXECUTE_IF_SET_IN_BITMAP. */
|
|
#define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, ITER) \
|
|
for (bmp_iter_set_init (&(ITER), (BITMAP), (MIN), &(BITNUM)); \
|
|
bmp_iter_set (&(ITER), &(BITNUM)); \
|
|
bmp_iter_next (&(ITER), &(BITNUM)))
|
|
#endif
|
|
|
|
inline void sbitmap_free (sbitmap map)
|
|
{
|
|
free (map);
|
|
}
|
|
|
|
inline void sbitmap_vector_free (sbitmap * vec)
|
|
{
|
|
free (vec);
|
|
}
|
|
|
|
extern void dump_bitmap (FILE *, const_sbitmap);
|
|
extern void debug_raw (const simple_bitmap_def &ref);
|
|
extern void debug_raw (const simple_bitmap_def *ptr);
|
|
extern void dump_bitmap_file (FILE *, const_sbitmap);
|
|
extern void debug (const simple_bitmap_def &ref);
|
|
extern void debug (const simple_bitmap_def *ptr);
|
|
extern void dump_bitmap_vector (FILE *, const char *, const char *, sbitmap *,
|
|
int);
|
|
extern sbitmap sbitmap_alloc (unsigned int);
|
|
extern sbitmap *sbitmap_vector_alloc (unsigned int, unsigned int);
|
|
extern sbitmap sbitmap_resize (sbitmap, unsigned int, int);
|
|
extern void bitmap_copy (sbitmap, const_sbitmap);
|
|
extern int bitmap_equal_p (const_sbitmap, const_sbitmap);
|
|
extern unsigned int bitmap_count_bits (const_sbitmap);
|
|
extern bool bitmap_empty_p (const_sbitmap);
|
|
extern void bitmap_clear (sbitmap);
|
|
extern void bitmap_clear_range (sbitmap, unsigned, unsigned);
|
|
extern void bitmap_set_range (sbitmap, unsigned, unsigned);
|
|
extern void bitmap_ones (sbitmap);
|
|
extern void bitmap_vector_clear (sbitmap *, unsigned int);
|
|
extern void bitmap_vector_ones (sbitmap *, unsigned int);
|
|
|
|
extern bool bitmap_ior_and_compl (sbitmap, const_sbitmap,
|
|
const_sbitmap, const_sbitmap);
|
|
extern void bitmap_and_compl (sbitmap, const_sbitmap, const_sbitmap);
|
|
extern void bitmap_not (sbitmap, const_sbitmap);
|
|
extern bool bitmap_or_and (sbitmap, const_sbitmap,
|
|
const_sbitmap, const_sbitmap);
|
|
extern bool bitmap_and_or (sbitmap, const_sbitmap,
|
|
const_sbitmap, const_sbitmap);
|
|
extern bool bitmap_intersect_p (const_sbitmap, const_sbitmap);
|
|
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 int bitmap_first_set_bit (const_sbitmap);
|
|
extern int bitmap_last_set_bit (const_sbitmap);
|
|
|
|
extern void debug_bitmap (const_sbitmap);
|
|
extern sbitmap sbitmap_realloc (sbitmap, unsigned int);
|
|
|
|
/* a class that ties the lifetime of a sbitmap to its scope. */
|
|
class auto_sbitmap
|
|
{
|
|
public:
|
|
explicit auto_sbitmap (unsigned int size) :
|
|
m_bitmap (sbitmap_alloc (size)) {}
|
|
~auto_sbitmap () { sbitmap_free (m_bitmap); }
|
|
|
|
/* Allow calling sbitmap functions on our bitmap. */
|
|
operator sbitmap () { return m_bitmap; }
|
|
operator const_sbitmap () const { return m_bitmap; }
|
|
|
|
private:
|
|
/* Prevent making a copy that refers to our sbitmap. */
|
|
auto_sbitmap (const auto_sbitmap &);
|
|
auto_sbitmap &operator = (const auto_sbitmap &);
|
|
auto_sbitmap (auto_sbitmap &&);
|
|
auto_sbitmap &operator = (auto_sbitmap &&);
|
|
|
|
/* The bitmap we are managing. */
|
|
sbitmap m_bitmap;
|
|
};
|
|
|
|
#endif /* ! GCC_SBITMAP_H */
|