-#define BITMAP_FREE(BITMAP) \
-do { \
- if (BITMAP) \
- { \
- bitmap_clear (BITMAP); \
- (BITMAP) = 0; \
- } \
-} while (0)
-
-/* Do any cleanup needed on an xmalloced bitmap when it is no longer used. */
-#define BITMAP_XFREE(BITMAP) \
-do { \
- if (BITMAP) \
- { \
- bitmap_clear (BITMAP); \
- free (BITMAP); \
- (BITMAP) = 0; \
- } \
-} while (0)
-
-/* Do any one-time initializations needed for bitmaps. */
-#define BITMAP_INIT_ONCE()
-
-/* Loop over all bits in BITMAP, starting with MIN, setting BITNUM to the
- bit number and executing CODE for all bits that are set. */
-
-#define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, CODE) \
-do { \
- bitmap_element *ptr_ = (BITMAP)->first; \
- unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
- unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
- unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
- % BITMAP_ELEMENT_WORDS); \
- \
- \
- /* Find the block the minimum bit is in. */ \
- while (ptr_ != 0 && ptr_->indx < indx_) \
- ptr_ = ptr_->next; \
- \
- if (ptr_ != 0 && ptr_->indx != indx_) \
- { \
- bit_num_ = 0; \
- word_num_ = 0; \
- } \
- \
- for (; ptr_ != 0; ptr_ = ptr_->next) \
- { \
- for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
- { \
- unsigned HOST_WIDE_INT word_ = ptr_->bits[word_num_]; \
- \
- if (word_ != 0) \
- { \
- for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
- { \
- unsigned HOST_WIDE_INT mask_ \
- = ((unsigned HOST_WIDE_INT) 1) << bit_num_; \
- \
- if ((word_ & mask_) != 0) \
- { \
- word_ &= ~ mask_; \
- (BITNUM) = (ptr_->indx * BITMAP_ELEMENT_ALL_BITS \
- + word_num_ * HOST_BITS_PER_WIDE_INT \
- + bit_num_); \
- CODE; \
- \
- if (word_ == 0) \
- break; \
- } \
- } \
- } \
- \
- bit_num_ = 0; \
- } \
- \
- word_num_ = 0; \
- } \
-} while (0)
-
-/* Loop over all bits in BITMAP1 and BITMAP2, starting with MIN, setting
- BITNUM to the bit number and executing CODE for all bits that are set in
- the first bitmap and not set in the second. */
-
-#define EXECUTE_IF_AND_COMPL_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, CODE) \
-do { \
- bitmap_element *ptr1_ = (BITMAP1)->first; \
- bitmap_element *ptr2_ = (BITMAP2)->first; \
- unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
- unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
- unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
- % BITMAP_ELEMENT_WORDS); \
- \
- /* Find the block the minimum bit is in in the first bitmap. */ \
- while (ptr1_ != 0 && ptr1_->indx < indx_) \
- ptr1_ = ptr1_->next; \
- \
- if (ptr1_ != 0 && ptr1_->indx != indx_) \
- { \
- bit_num_ = 0; \
- word_num_ = 0; \
- } \
- \
- for (; ptr1_ != 0 ; ptr1_ = ptr1_->next) \
- { \
- /* Advance BITMAP2 to the equivalent link, using an all \
- zero element if an equivalent link doesn't exist. */ \
- bitmap_element *tmp2_; \
- \
- while (ptr2_ != 0 && ptr2_->indx < ptr1_->indx) \
- ptr2_ = ptr2_->next; \
- \
- tmp2_ = ((ptr2_ != 0 && ptr2_->indx == ptr1_->indx) \
- ? ptr2_ : &bitmap_zero_bits); \
- \
- for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
- { \
- unsigned HOST_WIDE_INT word_ = (ptr1_->bits[word_num_] \
- & ~ tmp2_->bits[word_num_]); \
- if (word_ != 0) \
- { \
- for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
- { \
- unsigned HOST_WIDE_INT mask_ \
- = ((unsigned HOST_WIDE_INT)1) << bit_num_; \
- \
- if ((word_ & mask_) != 0) \
- { \
- word_ &= ~ mask_; \
- (BITNUM) = (ptr1_->indx * BITMAP_ELEMENT_ALL_BITS \
- + word_num_ * HOST_BITS_PER_WIDE_INT \
- + bit_num_); \
- \
- CODE; \
- if (word_ == 0) \
- break; \
- } \
- } \
- } \
- \
- bit_num_ = 0; \
- } \
- \
- word_num_ = 0; \
- } \
-} while (0)
-
-/* Loop over all bits in BITMAP1 and BITMAP2, starting with MIN, setting
- BITNUM to the bit number and executing CODE for all bits that are set in
- the both bitmaps. */
-
-#define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, CODE) \
-do { \
- bitmap_element *ptr1_ = (BITMAP1)->first; \
- bitmap_element *ptr2_ = (BITMAP2)->first; \
- unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
- unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
- unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
- % BITMAP_ELEMENT_WORDS); \
- \
- /* Find the block the minimum bit is in in the first bitmap. */ \
- while (ptr1_ != 0 && ptr1_->indx < indx_) \
- ptr1_ = ptr1_->next; \
- \
- if (ptr1_ != 0 && ptr1_->indx != indx_) \
- { \
- bit_num_ = 0; \
- word_num_ = 0; \
- } \
- \
- for (; ptr1_ != 0 ; ptr1_ = ptr1_->next) \
- { \
- /* Advance BITMAP2 to the equivalent link */ \
- while (ptr2_ != 0 && ptr2_->indx < ptr1_->indx) \
- ptr2_ = ptr2_->next; \
- \
- if (ptr2_ == 0) \
- { \
- /* If there are no more elements in BITMAP2, exit loop now. */ \
- ptr1_ = (bitmap_element *)0; \
- break; \
- } \
- else if (ptr2_->indx > ptr1_->indx) \
- { \
- bit_num_ = word_num_ = 0; \
- continue; \
- } \
- \
- for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
- { \
- unsigned HOST_WIDE_INT word_ = (ptr1_->bits[word_num_] \
- & ptr2_->bits[word_num_]); \
- if (word_ != 0) \
- { \
- for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
- { \
- unsigned HOST_WIDE_INT mask_ \
- = ((unsigned HOST_WIDE_INT)1) << bit_num_; \
- \
- if ((word_ & mask_) != 0) \
- { \
- word_ &= ~ mask_; \
- (BITNUM) = (ptr1_->indx * BITMAP_ELEMENT_ALL_BITS \
- + word_num_ * HOST_BITS_PER_WIDE_INT \
- + bit_num_); \
- \
- CODE; \
- if (word_ == 0) \
- break; \
- } \
- } \
- } \
- \
- bit_num_ = 0; \
- } \
- \
- word_num_ = 0; \
- } \
-} while (0)
+#define BITMAP_FREE(BITMAP) \
+ ((void) (bitmap_obstack_free ((bitmap) BITMAP), (BITMAP) = (bitmap) NULL))
+
+/* Iterator for bitmaps. */
+
+typedef struct
+{
+ /* 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 bits;
+} bitmap_iterator;
+
+/* Initialize a single bitmap iterator. START_BIT is the first bit to
+ iterate from. */
+
+static inline void
+bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map,
+ unsigned start_bit, unsigned *bit_no)
+{
+ bi->elt1 = map->first;
+ bi->elt2 = NULL;
+
+ /* Advance elt1 until it is not before the block containing start_bit. */
+ while (1)
+ {
+ 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;
+ }
+
+ /* 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;
+}
+
+/* Initialize an iterator to iterate over the intersection of two
+ bitmaps. START_BIT is the bit to commence from. */
+
+static inline void
+bmp_iter_and_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2,
+ unsigned start_bit, unsigned *bit_no)
+{
+ bi->elt1 = map1->first;
+ bi->elt2 = map2->first;
+
+ /* Advance elt1 until it is not before the block containing
+ start_bit. */
+ while (1)
+ {
+ if (!bi->elt1)
+ {
+ bi->elt2 = NULL;
+ break;
+ }
+
+ 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 (1)
+ {
+ 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 we're at the same index, then we have some intersecting bits. */
+ if (bi->elt1->indx == bi->elt2->indx)
+ {
+ /* 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
+ {
+ /* Otherwise we must immediately advance elt1, so initialize for
+ that. */
+ bi->word_no = BITMAP_ELEMENT_WORDS - 1;
+ bi->bits = 0;
+ }
+
+ /* 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;
+}
+
+/* Initialize an iterator to iterate over the bits in MAP1 & ~MAP2.
+ */
+
+static inline void
+bmp_iter_and_compl_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2,
+ unsigned start_bit, unsigned *bit_no)
+{
+ bi->elt1 = map1->first;
+ bi->elt2 = map2->first;
+
+ /* Advance elt1 until it is not before the block containing start_bit. */
+ while (1)
+ {
+ 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;
+ }
+
+ /* 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;
+}
+
+/* Advance to the next bit in BI. We don't advance to the next
+ nonzero bit yet. */
+
+static inline void
+bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
+{
+ bi->bits >>= 1;
+ *bit_no += 1;
+}
+
+/* Advance to the next nonzero bit of a single bitmap, we will have
+ already advanced past the just iterated bit. Return true if there
+ is a bit to iterate. */
+
+static inline bool
+bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
+{
+ /* If our current word is nonzero, 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)
+ {
+ /* Find the next nonzero 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;
+ }
+}
+
+/* Advance to the next nonzero bit of an intersecting pair of
+ bitmaps. We will have already advanced past the just iterated bit.
+ Return true if there is a bit to iterate. */
+
+static inline bool
+bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no)
+{
+ /* If our current word is nonzero, 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)
+ {
+ /* Find the next nonzero word in this elt. */
+ while (bi->word_no != BITMAP_ELEMENT_WORDS)
+ {
+ 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
+ {
+ /* Advance elt1 while it is less than elt2. We always want
+ to advance one elt. */
+ do
+ {
+ 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->elt1->indx != bi->elt2->indx);
+
+ *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
+ bi->word_no = 0;
+ }
+}
+
+/* Advance to the next nonzero bit in the intersection of
+ complemented bitmaps. We will have already advanced past the just
+ iterated bit. */
+
+static inline bool
+bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
+{
+ /* If our current word is nonzero, 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)
+ {
+ /* Find the next nonzero 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;
+ }
+}
+
+/* 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_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)))
projects / msp430-gcc.git / blobdiff