typedef struct
{
- /* Actual elements in the bitmaps. */
- bitmap_element *ptr1, *ptr2;
-
- /* Position of an actual word in the elements. */
- unsigned word;
-
- /* Position of a bit corresponding to the start of word. */
- unsigned word_bit;
-
- /* Position of the actual bit. */
- unsigned bit;
-
+ /* Pointer to the current bitmap element. */
+ bitmap_element *elt1;
+
+ /* Pointer to 2nd bitmap element when two are involved. */
+ bitmap_element *elt2;
+
+ /* Word within the current element. */
+ unsigned word_no;
+
/* Contents of the actually processed word. When finding next bit
it is shifted right, so that the actual bit is always the least
significant bit of ACTUAL. */
- BITMAP_WORD actual;
+ BITMAP_WORD bits;
} bitmap_iterator;
-/* Moves the iterator BI to the first set bit on or after the current
- position in bitmap and returns the bit if available. The bit is
- found in ACTUAL field only. */
+/* Initialize a single bitmap iterator. START_BIT is the first bit to
+ iterate from. */
-static inline unsigned
-bmp_iter_common_next_1 (bitmap_iterator *bi)
+static inline void
+bmp_iter_set_init (bitmap_iterator *bi, bitmap map,
+ unsigned start_bit, unsigned *bit_no)
{
- while (!(bi->actual & 1))
+ bi->elt1 = map->first;
+ bi->elt2 = NULL;
+
+ /* Advance elt1 until it is not before the block containing start_bit. */
+ while (1)
{
- bi->actual >>= 1;
- bi->bit++;
+ if (!bi->elt1)
+ {
+ bi->elt1 = &bitmap_zero_bits;
+ break;
+ }
+
+ if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
+ break;
+ bi->elt1 = bi->elt1->next;
}
- return bi->bit;
+ /* We might have gone past the start bit, so reinitialize it. */
+ if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
+ start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+
+ /* Initialize for what is now start_bit. */
+ bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
+ bi->bits = bi->elt1->bits[bi->word_no];
+ bi->bits >>= start_bit % BITMAP_WORD_BITS;
+
+ /* If this word is zero, we must make sure we're not pointing at the
+ first bit, otherwise our incrementing to the next word boundary
+ will fail. It won't matter if this increment moves us into the
+ next word. */
+ start_bit += !bi->bits;
+
+ *bit_no = start_bit;
}
-/* Moves the iterator BI to the first set bit on or after the current
- position in bitmap and returns the bit if available. */
+/* Initialize an iterator to iterate over the intersection of two
+ bitmaps. START_BIT is the bit to commence from. */
-static inline unsigned
-bmp_iter_single_next_1 (bitmap_iterator *bi)
+static inline void
+bmp_iter_and_init (bitmap_iterator *bi, bitmap map1, bitmap map2,
+ unsigned start_bit, unsigned *bit_no)
{
- if (bi->actual)
- return bmp_iter_common_next_1 (bi);
-
- bi->word++;
- bi->word_bit += BITMAP_WORD_BITS;
+ bi->elt1 = map1->first;
+ bi->elt2 = map2->first;
+ /* Advance elt1 until it is not before the block containing
+ start_bit. */
while (1)
{
- for (;
- bi->word < BITMAP_ELEMENT_WORDS;
- bi->word++, bi->word_bit += BITMAP_WORD_BITS)
+ if (!bi->elt1)
{
- bi->actual = bi->ptr1->bits[bi->word];
- if (bi->actual)
- {
- bi->bit = bi->word_bit;
- return bmp_iter_common_next_1 (bi);
- }
+ bi->elt2 = NULL;
+ break;
}
-
- bi->ptr1 = bi->ptr1->next;
- if (!bi->ptr1)
- return 0;
-
- bi->word = 0;
- bi->word_bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
+
+ if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
+ break;
+ bi->elt1 = bi->elt1->next;
}
-}
-
-/* Initializes a bitmap iterator BI for looping over bits of bitmap
- BMP, starting with bit MIN. Returns the first bit of BMP greater
- or equal to MIN if there is any. */
-
-static inline unsigned
-bmp_iter_single_init (bitmap_iterator *bi, bitmap bmp, unsigned min)
-{
- unsigned indx = min / BITMAP_ELEMENT_ALL_BITS;
-
- for (bi->ptr1 = bmp->first;
- bi->ptr1 && bi->ptr1->indx < indx;
- bi->ptr1 = bi->ptr1->next)
- continue;
-
- if (!bi->ptr1)
+
+ /* Advance elt2 until it is not before elt1. */
+ while (1)
{
- /* To avoid warnings. */
- bi->word = 0;
- bi->bit = 0;
- bi->word_bit = 0;
- bi->actual = 0;
- bi->ptr2 = NULL;
- return 0;
+ if (!bi->elt2)
+ {
+ bi->elt1 = bi->elt2 = &bitmap_zero_bits;
+ break;
+ }
+
+ if (bi->elt2->indx >= bi->elt1->indx)
+ break;
+ bi->elt2 = bi->elt2->next;
}
- if (bi->ptr1->indx == indx)
+ /* If we're at the same index, then we have some intersecting bits. */
+ if (bi->elt1->indx == bi->elt2->indx)
{
- unsigned bit_in_elt = min - BITMAP_ELEMENT_ALL_BITS * indx;
- unsigned word_in_elt = bit_in_elt / BITMAP_WORD_BITS;
- unsigned bit_in_word = bit_in_elt % BITMAP_WORD_BITS;
-
- bi->word = word_in_elt;
- bi->word_bit = min - bit_in_word;
- bi->bit = min;
- bi->actual = bi->ptr1->bits[word_in_elt] >> bit_in_word;
+ /* We might have advanced beyond the start_bit, so reinitialize
+ for that. */
+ if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
+ start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+
+ bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
+ bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
+ bi->bits >>= start_bit % BITMAP_WORD_BITS;
}
else
{
- bi->word = 0;
- bi->bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
- bi->word_bit = bi->bit;
- bi->actual = bi->ptr1->bits[0];
+ /* Otherwise we must immediately advance elt1, so initialize for
+ that. */
+ bi->word_no = BITMAP_ELEMENT_WORDS - 1;
+ bi->bits = 0;
}
-
- return bmp_iter_single_next_1 (bi);
+
+ /* If this word is zero, we must make sure we're not pointing at the
+ first bit, otherwise our incrementing to the next word boundary
+ will fail. It won't matter if this increment moves us into the
+ next word. */
+ start_bit += !bi->bits;
+
+ *bit_no = start_bit;
}
-/* Returns true if all elements of the bitmap referred to by iterator BI
- were processed. */
+/* Initialize an iterator to iterate over the bits in MAP1 & ~MAP2.
+ */
-static inline bool
-bmp_iter_end_p (const bitmap_iterator *bi)
+static inline void
+bmp_iter_and_compl_init (bitmap_iterator *bi, bitmap map1, bitmap map2,
+ unsigned start_bit, unsigned *bit_no)
{
- return bi->ptr1 == NULL;
-}
-
-/* Moves the iterator BI to the next bit of bitmap and returns the bit
- if available. */
-
-static inline unsigned
-bmp_iter_single_next (bitmap_iterator *bi)
-{
- bi->bit++;
- bi->actual >>= 1;
- return bmp_iter_single_next_1 (bi);
-}
-
-/* Loop over all bits in BITMAP, starting with MIN and setting BITNUM to
- the bit number. ITER is a bitmap iterator. */
-
-#define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, ITER) \
- for ((BITNUM) = bmp_iter_single_init (&(ITER), (BITMAP), (MIN)); \
- !bmp_iter_end_p (&(ITER)); \
- (BITNUM) = bmp_iter_single_next (&(ITER)))
-
-/* Moves the iterator BI to the first set bit on or after the current
- position in difference of bitmaps and returns the bit if available. */
-
-static inline unsigned
-bmp_iter_and_not_next_1 (bitmap_iterator *bi)
-{
- if (bi->actual)
- return bmp_iter_common_next_1 (bi);
-
- bi->word++;
- bi->word_bit += BITMAP_WORD_BITS;
+ bi->elt1 = map1->first;
+ bi->elt2 = map2->first;
+ /* Advance elt1 until it is not before the block containing start_bit. */
while (1)
{
- bitmap_element *snd;
-
- if (bi->ptr2 && bi->ptr2->indx == bi->ptr1->indx)
- snd = bi->ptr2;
- else
- snd = &bitmap_zero_bits;
-
- for (;
- bi->word < BITMAP_ELEMENT_WORDS;
- bi->word++, bi->word_bit += BITMAP_WORD_BITS)
+ if (!bi->elt1)
{
- bi->actual = (bi->ptr1->bits[bi->word]
- & ~snd->bits[bi->word]);
- if (bi->actual)
- {
- bi->bit = bi->word_bit;
- return bmp_iter_common_next_1 (bi);
- }
+ bi->elt1 = &bitmap_zero_bits;
+ break;
}
-
- bi->ptr1 = bi->ptr1->next;
- if (!bi->ptr1)
- return 0;
-
- while (bi->ptr2
- && bi->ptr2->indx < bi->ptr1->indx)
- bi->ptr2 = bi->ptr2->next;
-
- bi->word = 0;
- bi->word_bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
+
+ if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
+ break;
+ bi->elt1 = bi->elt1->next;
}
+
+ /* Advance elt2 until it is not before elt1. */
+ while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
+ bi->elt2 = bi->elt2->next;
+
+ /* We might have advanced beyond the start_bit, so reinitialize for
+ that. */
+ if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
+ start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+
+ bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
+ bi->bits = bi->elt1->bits[bi->word_no];
+ if (bi->elt2 && bi->elt1->indx == bi->elt2->indx)
+ bi->bits &= ~bi->elt2->bits[bi->word_no];
+ bi->bits >>= start_bit % BITMAP_WORD_BITS;
+
+ /* If this word is zero, we must make sure we're not pointing at the
+ first bit, otherwise our incrementing to the next word boundary
+ will fail. It won't matter if this increment moves us into the
+ next word. */
+ start_bit += !bi->bits;
+
+ *bit_no = start_bit;
}
-/* Initializes a bitmap iterator BI for looping over bits of bitmap
- BMP1 &~ BMP2, starting with bit MIN. Returns the first bit of
- BMP1 &~ BMP2 greater or equal to MIN if there is any. */
+/* Advance to the next bit in BI. We don't advance to the next
+ non-zero bit yet. */
-static inline unsigned
-bmp_iter_and_not_init (bitmap_iterator *bi, bitmap bmp1, bitmap bmp2,
- unsigned min)
+static inline void
+bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
{
- unsigned indx = min / BITMAP_ELEMENT_ALL_BITS;
+ bi->bits >>= 1;
+ *bit_no += 1;
+}
- for (bi->ptr1 = bmp1->first;
- bi->ptr1 && bi->ptr1->indx < indx;
- bi->ptr1 = bi->ptr1->next)
- continue;
+/* Advance to the next non-zero bit of a single bitmap, we will have
+ already advanced past the just iterated bit. Return true if there
+ is a bit to iterate. */
- if (!bi->ptr1)
+static inline bool
+bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
+{
+ /* If our current word is non-zero, it contains the bit we want. */
+ if (bi->bits)
{
- /* To avoid warnings. */
- bi->word = 0;
- bi->bit = 0;
- bi->word_bit = 0;
- bi->actual = 0;
- bi->ptr2 = NULL;
- return 0;
+ next_bit:
+ while (!(bi->bits & 1))
+ {
+ bi->bits >>= 1;
+ *bit_no += 1;
+ }
+ return true;
}
- for (bi->ptr2 = bmp2->first;
- bi->ptr2 && bi->ptr2->indx < bi->ptr1->indx;
- bi->ptr2 = bi->ptr2->next)
- continue;
+ /* Round up to the word boundary. We might have just iterated past
+ the end of the last word, hence the -1. It is not possible for
+ bit_no to point at the beginning of the now last word. */
+ *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
+ / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
+ bi->word_no++;
- if (bi->ptr1->indx == indx)
- {
- unsigned bit_in_elt = min - BITMAP_ELEMENT_ALL_BITS * indx;
- unsigned word_in_elt = bit_in_elt / BITMAP_WORD_BITS;
- unsigned bit_in_word = bit_in_elt % BITMAP_WORD_BITS;
-
- bi->word = word_in_elt;
- bi->word_bit = min - bit_in_word;
- bi->bit = min;
-
- if (bi->ptr2 && bi->ptr2->indx == indx)
- bi->actual = (bi->ptr1->bits[word_in_elt]
- & ~bi->ptr2->bits[word_in_elt]) >> bit_in_word;
- else
- bi->actual = bi->ptr1->bits[word_in_elt] >> bit_in_word;
- }
- else
+ while (1)
{
- bi->word = 0;
- bi->bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
- bi->word_bit = bi->bit;
-
- if (bi->ptr2 && bi->ptr2->indx == bi->ptr1->indx)
- bi->actual = (bi->ptr1->bits[0] & ~bi->ptr2->bits[0]);
- else
- bi->actual = bi->ptr1->bits[0];
+ /* Find the next non-zero word in this elt. */
+ while (bi->word_no != BITMAP_ELEMENT_WORDS)
+ {
+ bi->bits = bi->elt1->bits[bi->word_no];
+ if (bi->bits)
+ goto next_bit;
+ *bit_no += BITMAP_WORD_BITS;
+ bi->word_no++;
+ }
+
+ /* Advance to the next element. */
+ bi->elt1 = bi->elt1->next;
+ if (!bi->elt1)
+ return false;
+ *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+ bi->word_no = 0;
}
-
- return bmp_iter_and_not_next_1 (bi);
-}
-
-/* Moves the iterator BI to the next bit of difference of bitmaps and returns
- the bit if available. */
-
-static inline unsigned
-bmp_iter_and_not_next (bitmap_iterator *bi)
-{
- bi->bit++;
- bi->actual >>= 1;
- return bmp_iter_and_not_next_1 (bi);
}
-/* Loop over all bits in BMP1 and BMP2, starting with MIN, setting
- BITNUM to the bit number for all bits that are set in the first bitmap
- and not set in the second. ITER is a bitmap iterator. */
+/* Advance to the next non-zero bit of an intersecting pair of
+ bitmaps. We will have alreadt advanced past the just iterated bit.
+ Return true if there is a bit to iterate. */
-#define EXECUTE_IF_AND_COMPL_IN_BITMAP(BMP1, BMP2, MIN, BITNUM, ITER) \
- for ((BITNUM) = bmp_iter_and_not_init (&(ITER), (BMP1), (BMP2), (MIN)); \
- !bmp_iter_end_p (&(ITER)); \
- (BITNUM) = bmp_iter_and_not_next (&(ITER)))
-
-/* Moves the iterator BI to the first set bit on or after the current
- position in intersection of bitmaps and returns the bit if available. */
-
-static inline unsigned
-bmp_iter_and_next_1 (bitmap_iterator *bi)
+static inline bool
+bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no)
{
- if (bi->actual)
- return bmp_iter_common_next_1 (bi);
-
- bi->word++;
- bi->word_bit += BITMAP_WORD_BITS;
+ /* If our current word is non-zero, it contains the bit we want. */
+ if (bi->bits)
+ {
+ next_bit:
+ while (!(bi->bits & 1))
+ {
+ bi->bits >>= 1;
+ *bit_no += 1;
+ }
+ return true;
+ }
+ /* Round up to the word boundary. We might have just iterated past
+ the end of the last word, hence the -1. It is not possible for
+ bit_no to point at the beginning of the now last word. */
+ *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
+ / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
+ bi->word_no++;
+
while (1)
{
- for (;
- bi->word < BITMAP_ELEMENT_WORDS;
- bi->word++, bi->word_bit += BITMAP_WORD_BITS)
+ /* Find the next non-zero word in this elt. */
+ while (bi->word_no != BITMAP_ELEMENT_WORDS)
{
- bi->actual = (bi->ptr1->bits[bi->word]
- & bi->ptr2->bits[bi->word]);
- if (bi->actual)
- {
- bi->bit = bi->word_bit;
- return bmp_iter_common_next_1 (bi);
- }
+ bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
+ if (bi->bits)
+ goto next_bit;
+ *bit_no += BITMAP_WORD_BITS;
+ bi->word_no++;
}
-
+
+ /* Advance to the next identical element. */
do
{
- bi->ptr1 = bi->ptr1->next;
- if (!bi->ptr1)
- return 0;
-
- while (bi->ptr2->indx < bi->ptr1->indx)
+ /* Advance elt1 while it is less than elt2. We always want
+ to advance one elt. */
+ do
{
- bi->ptr2 = bi->ptr2->next;
- if (!bi->ptr2)
- {
- bi->ptr1 = NULL;
- return 0;
- }
+ bi->elt1 = bi->elt1->next;
+ if (!bi->elt1)
+ return false;
+ }
+ while (bi->elt1->indx < bi->elt2->indx);
+
+ /* Advance elt2 to be no less than elt1. This might not
+ advance. */
+ while (bi->elt2->indx < bi->elt1->indx)
+ {
+ bi->elt2 = bi->elt2->next;
+ if (!bi->elt2)
+ return false;
}
}
- while (bi->ptr1->indx != bi->ptr2->indx);
-
- bi->word = 0;
- bi->word_bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
+ while (bi->elt1->indx != bi->elt2->indx);
+
+ *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+ bi->word_no = 0;
}
}
-/* Initializes a bitmap iterator BI for looping over bits of bitmap
- BMP1 & BMP2, starting with bit MIN. Returns the first bit of
- BMP1 & BMP2 greater or equal to MIN if there is any. */
+/* Advance to the next non-zero bit in the intersection of
+ complemented bitmaps. We will have already advanced past the just
+ iterated bit. */
-static inline unsigned
-bmp_iter_and_init (bitmap_iterator *bi, bitmap bmp1, bitmap bmp2,
- unsigned min)
+static inline bool
+bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
{
- unsigned indx = min / BITMAP_ELEMENT_ALL_BITS;
-
- for (bi->ptr1 = bmp1->first;
- bi->ptr1 && bi->ptr1->indx < indx;
- bi->ptr1 = bi->ptr1->next)
- continue;
-
- if (!bi->ptr1)
- goto empty;
-
- bi->ptr2 = bmp2->first;
- if (!bi->ptr2)
- goto empty;
-
- while (1)
+ /* If our current word is non-zero, it contains the bit we want. */
+ if (bi->bits)
{
- while (bi->ptr2->indx < bi->ptr1->indx)
+ next_bit:
+ while (!(bi->bits & 1))
{
- bi->ptr2 = bi->ptr2->next;
- if (!bi->ptr2)
- goto empty;
+ bi->bits >>= 1;
+ *bit_no += 1;
}
-
- if (bi->ptr1->indx == bi->ptr2->indx)
- break;
-
- bi->ptr1 = bi->ptr1->next;
- if (!bi->ptr1)
- goto empty;
+ return true;
}
- if (bi->ptr1->indx == indx)
- {
- unsigned bit_in_elt = min - BITMAP_ELEMENT_ALL_BITS * indx;
- unsigned word_in_elt = bit_in_elt / BITMAP_WORD_BITS;
- unsigned bit_in_word = bit_in_elt % BITMAP_WORD_BITS;
-
- bi->word = word_in_elt;
- bi->word_bit = min - bit_in_word;
- bi->bit = min;
+ /* Round up to the word boundary. We might have just iterated past
+ the end of the last word, hence the -1. It is not possible for
+ bit_no to point at the beginning of the now last word. */
+ *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
+ / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
+ bi->word_no++;
- bi->actual = (bi->ptr1->bits[word_in_elt]
- & bi->ptr2->bits[word_in_elt]) >> bit_in_word;
- }
- else
+ while (1)
{
- bi->word = 0;
- bi->bit = bi->ptr1->indx * BITMAP_ELEMENT_ALL_BITS;
- bi->word_bit = bi->bit;
-
- bi->actual = (bi->ptr1->bits[0] & bi->ptr2->bits[0]);
+ /* Find the next non-zero word in this elt. */
+ while (bi->word_no != BITMAP_ELEMENT_WORDS)
+ {
+ bi->bits = bi->elt1->bits[bi->word_no];
+ if (bi->elt2 && bi->elt2->indx == bi->elt1->indx)
+ bi->bits &= ~bi->elt2->bits[bi->word_no];
+ if (bi->bits)
+ goto next_bit;
+ *bit_no += BITMAP_WORD_BITS;
+ bi->word_no++;
+ }
+
+ /* Advance to the next element of elt1. */
+ bi->elt1 = bi->elt1->next;
+ if (!bi->elt1)
+ return false;
+
+ /* Advance elt2 until it is no less than elt1. */
+ while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
+ bi->elt2 = bi->elt2->next;
+
+ *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+ bi->word_no = 0;
}
-
- return bmp_iter_and_next_1 (bi);
-
-empty:
- /* To avoid warnings. */
- bi->word = 0;
- bi->bit = 0;
- bi->word_bit = 0;
- bi->actual = 0;
- bi->ptr1 = NULL;
- bi->ptr2 = NULL;
- return 0;
-}
-
-/* Moves the iterator BI to the next bit of intersection of bitmaps and returns
- the bit if available. */
-
-static inline unsigned
-bmp_iter_and_next (bitmap_iterator *bi)
-{
- bi->bit++;
- bi->actual >>= 1;
- return bmp_iter_and_next_1 (bi);
}
-/* Loop over all bits in BMP1 and BMP2, starting with MIN, setting
- BITNUM to the bit number for all bits that are set in both bitmaps.
- ITER is a bitmap iterator. */
+/* Loop over all bits set in BITMAP, starting with MIN and setting
+ BITNUM to the bit number. ITER is a bitmap iterator. BITNUM
+ should be treated as a read-only variable as it contains loop
+ state. */
-#define EXECUTE_IF_AND_IN_BITMAP(BMP1, BMP2, MIN, BITNUM, ITER) \
- for ((BITNUM) = bmp_iter_and_init (&(ITER), (BMP1), (BMP2), (MIN)); \
- !bmp_iter_end_p (&(ITER)); \
- (BITNUM) = bmp_iter_and_next (&(ITER)))
+#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)))
+
+/* Loop over all the bits set in BITMAP1 & BITMAP2, starting with MIN
+ and setting BITNUM to the bit number. ITER is a bitmap iterator.
+ BITNUM should be treated as a read-only variable as it contains
+ loop state. */
+
+#define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \
+ for (bmp_iter_and_init (&(ITER), (BITMAP1), (BITMAP2), (MIN), \
+ &(BITNUM)); \
+ bmp_iter_and (&(ITER), &(BITNUM)); \
+ bmp_iter_next (&(ITER), &(BITNUM)))
+
+/* Loop over all the bits set in BITMAP1 & ~BITMAP2, starting with MIN
+ and setting BITNUM to the bit number. ITER is a bitmap iterator.
+ BITNUM should be treated as a read-only variable as it contains
+ loop state. */
+
+#define EXECUTE_IF_AND_COMPL_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \
+ for (bmp_iter_and_compl_init (&(ITER), (BITMAP1), (BITMAP2), (MIN), \
+ &(BITNUM)); \
+ bmp_iter_and_compl (&(ITER), &(BITNUM)); \
+ bmp_iter_next (&(ITER), &(BITNUM)))
#endif /* GCC_BITMAP_H */
projects / thirdparty / gcc.git / commitdiff
