static bitmap_element *bitmap_element_allocate (bitmap);
static int bitmap_element_zerop (bitmap_element *);
static void bitmap_element_link (bitmap, bitmap_element *);
+static bitmap_element *bitmap_elt_insert_after (bitmap, bitmap_element *);
+static void bitmap_elt_clear_from (bitmap, bitmap_element *);
static bitmap_element *bitmap_find_bit (bitmap, unsigned int);
\f
+
/* Add ELEM to the appropriate freelist. */
static INLINE void
bitmap_elem_to_freelist (bitmap head, bitmap_element *elt)
head->current = element;
head->indx = indx;
}
+
+/* Insert a new uninitialized element into bitmap HEAD after element
+ ELT. If ELT is NULL, insert the element at the start. Return the
+ new element. */
+
+static bitmap_element *
+bitmap_elt_insert_after (bitmap head, bitmap_element *elt)
+{
+ bitmap_element *node = bitmap_element_allocate (head);
+
+ if (!elt)
+ {
+ if (!head->current)
+ head->current = node;
+ node->next = head->first;
+ if (node->next)
+ node->next->prev = node;
+ head->first = node;
+ node->prev = NULL;
+ }
+ else
+ {
+ gcc_assert (head->current);
+ node->next = elt->next;
+ if (node->next)
+ node->next->prev = node;
+ elt->next = node;
+ node->prev = elt;
+ }
+ return node;
+}
+
+/* Remove ELT and all following elements from bitmap HEAD. */
+
+void
+bitmap_elt_clear_from (bitmap head, bitmap_element *elt)
+{
+ bitmap_element *next;
+
+ while (elt)
+ {
+ next = elt->next;
+ bitmap_element_free (head, elt);
+ elt = next;
+ }
+}
+
\f
/* Clear a bitmap by freeing the linked list. */
+ bit_num);
}
\f
-/* Store in bitmap TO the result of combining bitmap FROM1 and FROM2 using
- a specific bit manipulation. Return true if TO changes. */
-
-int
-bitmap_operation (bitmap to, bitmap from1, bitmap from2,
- enum bitmap_bits operation)
-{
-#define HIGHEST_INDEX (unsigned int) ~0
-
- bitmap_element *from1_ptr = from1->first;
- bitmap_element *from2_ptr = from2->first;
- unsigned int indx1 = (from1_ptr) ? from1_ptr->indx : HIGHEST_INDEX;
- unsigned int indx2 = (from2_ptr) ? from2_ptr->indx : HIGHEST_INDEX;
- bitmap_element *to_ptr = to->first;
- bitmap_element *from1_tmp;
- bitmap_element *from2_tmp;
- bitmap_element *to_tmp;
- unsigned int indx;
- int changed = 0;
-#if BITMAP_ELEMENT_WORDS == 2
-#define DOIT(OP) \
- do { \
- BITMAP_WORD t0, t1, f10, f11, f20, f21; \
- f10 = from1_tmp->bits[0]; \
- f20 = from2_tmp->bits[0]; \
- t0 = f10 OP f20; \
- changed |= (t0 != to_tmp->bits[0]); \
- f11 = from1_tmp->bits[1]; \
- f21 = from2_tmp->bits[1]; \
- t1 = f11 OP f21; \
- changed |= (t1 != to_tmp->bits[1]); \
- to_tmp->bits[0] = t0; \
- to_tmp->bits[1] = t1; \
- } while (0)
-#else
-#define DOIT(OP) \
- do { \
- BITMAP_WORD t, f1, f2; \
- int i; \
- for (i = 0; i < BITMAP_ELEMENT_WORDS; ++i) \
- { \
- f1 = from1_tmp->bits[i]; \
- f2 = from2_tmp->bits[i]; \
- t = f1 OP f2; \
- changed |= (t != to_tmp->bits[i]); \
- to_tmp->bits[i] = t; \
- } \
- } while (0)
-#endif
+/* DST = A & B. */
- to->first = to->current = 0;
+void
+bitmap_and (bitmap dst, bitmap a, bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
- while (from1_ptr != 0 || from2_ptr != 0)
+ gcc_assert (dst != a && dst != b && a != b);
+ while (a_elt && b_elt)
{
- /* Figure out whether we need to substitute zero elements for
- missing links. */
- if (indx1 == indx2)
+ if (a_elt->indx < b_elt->indx)
+ a_elt = a_elt->next;
+ else if (b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
+ else
{
- indx = indx1;
- from1_tmp = from1_ptr;
- from2_tmp = from2_ptr;
- from1_ptr = from1_ptr->next;
- indx1 = (from1_ptr) ? from1_ptr->indx : HIGHEST_INDEX;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : HIGHEST_INDEX;
+ /* Matching elts, generate A & B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+
+ dst_elt->indx = a_elt->indx;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] & b_elt->bits[ix];
+
+ dst_elt->bits[ix] = r;
+ ior |= r;
+ }
+ if (ior)
+ {
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ }
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
}
- else if (indx1 < indx2)
+ }
+ bitmap_elt_clear_from (dst, dst_elt);
+ gcc_assert (!dst->current == !dst->first);
+ if (dst->current)
+ dst->indx = dst->current->indx;
+}
+
+/* A &= B. */
+
+void
+bitmap_and_into (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *next;
+
+ gcc_assert (a != b);
+ while (a_elt && b_elt)
+ {
+ if (a_elt->indx < b_elt->indx)
{
- indx = indx1;
- from1_tmp = from1_ptr;
- from2_tmp = &bitmap_zero_bits;
- from1_ptr = from1_ptr->next;
- indx1 = (from1_ptr) ? from1_ptr->indx : HIGHEST_INDEX;
+ next = a_elt->next;
+ bitmap_element_free (a, a_elt);
+ a_elt = next;
}
+ else if (b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
else
{
- indx = indx2;
- from1_tmp = &bitmap_zero_bits;
- from2_tmp = from2_ptr;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : HIGHEST_INDEX;
+ /* Matching elts, generate A &= B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] & b_elt->bits[ix];
+
+ a_elt->bits[ix] = r;
+ ior |= r;
+ }
+ next = a_elt->next;
+ if (!ior)
+ bitmap_element_free (a, a_elt);
+ a_elt = next;
+ b_elt = b_elt->next;
}
+ }
+ bitmap_elt_clear_from (a, a_elt);
+ gcc_assert (!a->current == !a->first);
+ gcc_assert (!a->current || a->indx == a->current->indx);
+}
+
+/* DST = A & ~B */
+
+void
+bitmap_and_compl (bitmap dst, bitmap a, bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
- /* Find the appropriate element from TO. Begin by discarding
- elements that we've skipped. */
- while (to_ptr && to_ptr->indx < indx)
+ gcc_assert (dst != a && dst != b && a != b);
+
+ while (a_elt)
+ {
+ if (!b_elt || a_elt->indx < b_elt->indx)
{
- changed = 1;
- to_tmp = to_ptr;
- to_ptr = to_ptr->next;
- bitmap_elem_to_freelist (to, to_tmp);
+ /* Copy a_elt. */
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+
+ dst_elt->indx = a_elt->indx;
+ memcpy (dst_elt->bits, a_elt->bits, sizeof (dst_elt->bits));
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ a_elt = a_elt->next;
}
- if (to_ptr && to_ptr->indx == indx)
+ else if (b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
+ else
{
- to_tmp = to_ptr;
- to_ptr = to_ptr->next;
+ /* Matching elts, generate A & ~B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+
+ dst_elt->indx = a_elt->indx;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] & ~b_elt->bits[ix];
+
+ dst_elt->bits[ix] = r;
+ ior |= r;
+ }
+ if (ior)
+ {
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ }
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
}
+ }
+ bitmap_elt_clear_from (dst, dst_elt);
+ gcc_assert (!dst->current == !dst->first);
+ if (dst->current)
+ dst->indx = dst->current->indx;
+}
+
+/* A &= ~B */
+
+void
+bitmap_and_compl_into (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *next;
+
+ gcc_assert (a != b);
+ while (a_elt && b_elt)
+ {
+ if (a_elt->indx < b_elt->indx)
+ a_elt = a_elt->next;
+ else if (b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
else
- to_tmp = bitmap_element_allocate (to);
+ {
+ /* Matching elts, generate A &= ~B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] & ~b_elt->bits[ix];
+
+ a_elt->bits[ix] = r;
+ ior |= r;
+ }
+ next = a_elt->next;
+ if (!ior)
+ bitmap_element_free (a, a_elt);
+ a_elt = next;
+ b_elt = b_elt->next;
+ }
+ }
+ gcc_assert (!a->current == !a->first);
+ gcc_assert (!a->current || a->indx == a->current->indx);
+}
- /* Do the operation, and if any bits are set, link it into the
- linked list. */
- switch (operation)
+/* DST = A | B. Return true if DST changes. */
+
+bool
+bitmap_ior (bitmap dst, bitmap a, bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+ bool changed = false;
+
+ gcc_assert (dst != a && dst != b && a != b);
+ while (a_elt || b_elt)
+ {
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
{
- default:
- gcc_unreachable ();
-
- case BITMAP_AND:
- DOIT (&);
- break;
-
- case BITMAP_AND_COMPL:
- DOIT (&~);
- break;
-
- case BITMAP_IOR:
- DOIT (|);
- break;
- case BITMAP_IOR_COMPL:
- DOIT (|~);
- break;
- case BITMAP_XOR:
- DOIT (^);
- break;
+ /* Matching elts, generate A | B. */
+ unsigned ix;
+
+ if (!changed && dst_elt && dst_elt->indx == a_elt->indx)
+ {
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] | b_elt->bits[ix];
+
+ if (r != dst_elt->bits[ix])
+ {
+ dst_elt->bits[ix] = r;
+ changed = true;
+ }
+ }
+ }
+ else
+ {
+ changed = true;
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+ dst_elt->indx = a_elt->indx;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] | b_elt->bits[ix];
+
+ dst_elt->bits[ix] = r;
+ }
+ }
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
}
+ else
+ {
+ /* Copy a single element. */
+ bitmap_element *src;
- if (! bitmap_element_zerop (to_tmp))
+ if (!b_elt || (a_elt && a_elt->indx < b_elt->indx))
+ {
+ src = a_elt;
+ a_elt = a_elt->next;
+ }
+ else
+ {
+ src = b_elt;
+ b_elt = b_elt->next;
+ }
+
+ if (!changed && dst_elt && dst_elt->indx == src->indx)
+ {
+ unsigned ix;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ if (src->bits[ix] != dst_elt->bits[ix])
+ {
+ dst_elt->bits[ix] = src->bits[ix];
+ changed = true;
+ }
+ }
+ else
+ {
+ changed = true;
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+ dst_elt->indx = src->indx;
+ memcpy (dst_elt->bits, src->bits, sizeof (dst_elt->bits));
+ }
+
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ }
+ }
+
+ if (dst_elt)
+ {
+ changed = true;
+ bitmap_elt_clear_from (dst, dst_elt);
+ }
+ gcc_assert (!dst->current == !dst->first);
+ if (dst->current)
+ dst->indx = dst->current->indx;
+ return changed;
+}
+
+/* A |= B. Return true if A changes. */
+
+bool
+bitmap_ior_into (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *a_prev = NULL;
+ bool changed = false;
+
+ gcc_assert (a != b);
+ while (b_elt)
+ {
+ if (!a_elt || b_elt->indx < a_elt->indx)
+ {
+ /* Copy b_elt. */
+ bitmap_element *dst = bitmap_elt_insert_after (a, a_prev);
+
+ dst->indx = b_elt->indx;
+ memcpy (dst->bits, b_elt->bits, sizeof (dst->bits));
+ a_prev = dst;
+ b_elt = b_elt->next;
+ changed = true;
+ }
+ else if (a_elt->indx < b_elt->indx)
{
- to_tmp->indx = indx;
- bitmap_element_link (to, to_tmp);
+ a_prev = a_elt;
+ a_elt = a_elt->next;
}
else
{
- bitmap_elem_to_freelist (to, to_tmp);
+ /* Matching elts, generate A |= B. */
+ unsigned ix;
+
+ if (changed)
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] | b_elt->bits[ix];
+
+ a_elt->bits[ix] = r;
+ }
+ else
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] | b_elt->bits[ix];
+
+ if (a_elt->bits[ix] != r)
+ {
+ changed = true;
+ a_elt->bits[ix] = r;
+ }
+ }
+ b_elt = b_elt->next;
+ a_prev = a_elt;
+ a_elt = a_elt->next;
}
}
+ gcc_assert (!a->current == !a->first);
+ if (a->current)
+ a->indx = a->current->indx;
+ return changed;
+}
- /* If we have elements of TO left over, free the lot. */
- if (to_ptr)
+/* DST = A ^ B */
+
+void
+bitmap_xor (bitmap dst, bitmap a, bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+
+ gcc_assert (dst != a && dst != b && a != b);
+ while (a_elt || b_elt)
{
- changed = 1;
- for (to_tmp = to_ptr; to_tmp->next ; to_tmp = to_tmp->next)
- continue;
- if (to->using_obstack)
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
{
- to_tmp->next = bitmap_free;
- bitmap_free = to_ptr;
+ /* Matching elts, generate A ^ B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+
+ dst_elt->indx = a_elt->indx;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] ^ b_elt->bits[ix];
+
+ ior |= r;
+ dst_elt->bits[ix] = r;
+ }
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ if (ior)
+ {
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ }
}
else
{
- to_tmp->next = bitmap_ggc_free;
- bitmap_ggc_free = to_ptr;
+ /* Copy a single element. */
+ bitmap_element *src;
+
+ if (!b_elt || (a_elt && a_elt->indx < b_elt->indx))
+ {
+ src = a_elt;
+ a_elt = a_elt->next;
+ }
+ else
+ {
+ src = b_elt;
+ b_elt = b_elt->next;
+ }
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev);
+
+ dst_elt->indx = src->indx;
+ memcpy (dst_elt->bits, src->bits, sizeof (dst_elt->bits));
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
}
}
+ bitmap_elt_clear_from (dst, dst_elt);
+ gcc_assert (!dst->current == !dst->first);
+ if (dst->current)
+ dst->indx = dst->current->indx;
+}
-#undef DOIT
+/* A ^= B */
- return changed;
+void
+bitmap_xor_into (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ bitmap_element *b_elt = b->first;
+ bitmap_element *a_prev = NULL;
+
+ gcc_assert (a != b);
+ while (b_elt)
+ {
+ if (!a_elt || b_elt->indx < a_elt->indx)
+ {
+ /* Copy b_elt. */
+ bitmap_element *dst = bitmap_elt_insert_after (a, a_prev);
+
+ dst->indx = b_elt->indx;
+ memcpy (dst->bits, b_elt->bits, sizeof (dst->bits));
+ a_prev = dst;
+ b_elt = b_elt->next;
+ }
+ else if (a_elt->indx < b_elt->indx)
+ {
+ a_prev = a_elt;
+ a_elt = a_elt->next;
+ }
+ else
+ {
+ /* Matching elts, generate A ^= B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+ bitmap_element *next = a_elt->next;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = a_elt->bits[ix] ^ b_elt->bits[ix];
+
+ ior |= r;
+ a_elt->bits[ix] = r;
+ }
+ b_elt = b_elt->next;
+ if (ior)
+ a_prev = a_elt;
+ else
+ bitmap_element_free (a, a_elt);
+ a_elt = next;
+ }
+ }
+ gcc_assert (!a->current == !a->first);
+ if (a->current)
+ a->indx = a->current->indx;
}
/* Return true if two bitmaps are identical.
}
\f
-/* Produce TO |= FROM1 & ~FROM2. Return true, if TO changed. */
+/* DST = A | (FROM1 & ~FROM2). Return true if DST changes. */
bool
-bitmap_ior_and_compl_into (bitmap to, bitmap from1, bitmap from2)
+bitmap_ior_and_compl (bitmap dst, bitmap a, bitmap from1, bitmap from2)
{
bitmap_head tmp;
- int changed;
-
+ bool changed;
+
tmp.first = tmp.current = 0;
tmp.using_obstack = 0;
-
bitmap_and_compl (&tmp, from1, from2);
- changed = bitmap_operation (to, to, &tmp, BITMAP_IOR);
+ changed = bitmap_ior (dst, a, &tmp);
bitmap_clear (&tmp);
+
return changed;
}
-/* Produce DST = A | (B & ~C). Return true if DST != A. */
+/* A |= (FROM1 & ~FROM2). Return true if A changes. */
bool
-bitmap_ior_and_compl (bitmap dst, bitmap a, bitmap b, bitmap c)
+bitmap_ior_and_compl_into (bitmap a, bitmap from1, bitmap from2)
{
bitmap_head tmp;
- int changed;
-
+ bool changed;
+
tmp.first = tmp.current = 0;
tmp.using_obstack = 0;
-
- bitmap_and_compl (&tmp, b, c);
- changed = bitmap_operation (dst, a, &tmp, BITMAP_IOR);
+ bitmap_and_compl (&tmp, from1, from2);
+ changed = bitmap_ior_into (a, &tmp);
bitmap_clear (&tmp);
return changed;
} bitmap_head;
typedef struct bitmap_head_def *bitmap;
-/* Enumeration giving the various operations we support. */
-enum bitmap_bits {
- BITMAP_AND, /* TO = FROM1 & FROM2 */
- BITMAP_AND_COMPL, /* TO = FROM1 & ~ FROM2 */
- BITMAP_IOR, /* TO = FROM1 | FROM2 */
- BITMAP_XOR, /* TO = FROM1 ^ FROM2 */
- BITMAP_IOR_COMPL /* TO = FROM1 | ~FROM2 */
-};
-
/* Global data */
extern bitmap_element bitmap_zero_bits; /* Zero bitmap element */
/* True if MAP is an empty bitmap. */
#define bitmap_empty_p(MAP) (!(MAP)->first)
-/* Perform an operation on two bitmaps, yielding a third. */
-extern int bitmap_operation (bitmap, bitmap, bitmap, enum bitmap_bits);
-
-#define bitmap_and(DST,A,B) (void)bitmap_operation (DST,A,B,BITMAP_AND)
-#define bitmap_and_into(DST_SRC,B) (void)bitmap_operation (DST_SRC,DST_SRC,B,BITMAP_AND)
-#define bitmap_and_compl(DST,A,B) (void)bitmap_operation (DST,A,B,BITMAP_AND_COMPL)
-#define bitmap_and_compl_into(DST_SRC,B) (void)bitmap_operation (DST_SRC,DST_SRC,B,BITMAP_AND_COMPL)
-#define bitmap_ior(DST,A,B) (void)bitmap_operation (DST,A,B,BITMAP_IOR)
-#define bitmap_ior_into(DST_SRC,B) (void)bitmap_operation (DST_SRC,DST_SRC,B,BITMAP_IOR)
-#define bitmap_ior_compl(DST,A,B) (void)bitmap_operation (DST,A,Br,BITMAP_IOR_COMPL)
-#define bitmap_xor(DST,A,B) (void)bitmap_operation (DST,A,B,BITMAP_XOR)
-#define bitmap_xor_into(DST_SRC,B) (void)bitmap_operation (DST_SRC,DST_SRC,B,BITMAP_XOR)
-
-/* `or' into one bitmap the `and' of a second bitmap witih the complement
- of a third. Return nonzero if the bitmap changes. */
-extern bool bitmap_ior_and_compl_into (bitmap, bitmap, bitmap);
-extern bool bitmap_ior_and_compl (bitmap, bitmap, bitmap, bitmap);
+/* Boolean operations on bitmaps. The _into variants are two operand
+ versions that modify the first source operand. The other variants
+ are three operand versions that to not destroy the source bitmaps.
+ The operations supported are &, & ~, |, ^. */
+extern void bitmap_and (bitmap, bitmap, bitmap);
+extern void bitmap_and_into (bitmap, bitmap);
+extern void bitmap_and_compl (bitmap, bitmap, bitmap);
+extern void bitmap_and_compl_into (bitmap, bitmap);
+extern bool bitmap_ior (bitmap, bitmap, bitmap);
+extern bool bitmap_ior_into (bitmap, bitmap);
+extern void bitmap_xor (bitmap, bitmap, bitmap);
+extern void bitmap_xor_into (bitmap, bitmap);
+
+/* DST = A | (B & ~C). Return true if DST changes. */
+extern bool bitmap_ior_and_compl (bitmap DST, bitmap A, bitmap B, bitmap C);
+/* A |= (B & ~C). Return true if A changes. */
+extern bool bitmap_ior_and_compl_into (bitmap DST, bitmap B, bitmap C);
/* Clear a single register in a register set. */
extern void bitmap_clear_bit (bitmap, int);
projects / thirdparty / gcc.git / commitdiff
