/* Functions to support general ended bitmaps.
- Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004
+ Free Software Foundation, Inc.
-This file is part of GNU CC.
+This file is part of GCC.
-GNU CC 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 2, or (at your option)
-any later version.
+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 2, or (at your option) any later
+version.
-GNU CC 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.
+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 GNU CC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+along with GCC; see the file COPYING. If not, write to the Free
+Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+02111-1307, USA. */
#include "config.h"
#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
#include "rtl.h"
#include "flags.h"
#include "obstack.h"
-#include "regs.h"
-#include "basic-block.h"
-
-/* Obstack to allocate bitmap elements from. */
-static struct obstack bitmap_obstack;
-static int bitmap_obstack_init = FALSE;
-\f
-#ifndef INLINE
-#ifndef __GNUC__
-#define INLINE
-#else
-#define INLINE __inline__
-#endif
-#endif
+#include "ggc.h"
+#include "bitmap.h"
/* Global data */
-bitmap_element bitmap_zero; /* An element of all zero bits. */
-bitmap_element *bitmap_free; /* Freelist of bitmap elements. */
-
-static void bitmap_element_free PARAMS ((bitmap, bitmap_element *));
-static bitmap_element *bitmap_element_allocate PARAMS ((void));
-static int bitmap_element_zerop PARAMS ((bitmap_element *));
-static void bitmap_element_link PARAMS ((bitmap, bitmap_element *));
-static bitmap_element *bitmap_find_bit PARAMS ((bitmap, unsigned int));
+bitmap_element bitmap_zero_bits; /* An element of all zero bits. */
+bitmap_obstack bitmap_default_obstack; /* The default bitmap obstack. */
+static GTY((deletable)) bitmap_element *bitmap_ggc_free; /* Freelist of
+ GC'd elements. */
+
+static void bitmap_elem_to_freelist (bitmap, bitmap_element *);
+static void bitmap_element_free (bitmap, bitmap_element *);
+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
-/* Free a bitmap element */
-static INLINE void
-bitmap_element_free (head, elt)
- bitmap head;
- bitmap_element *elt;
+/* Add ELEM to the appropriate freelist. */
+static inline void
+bitmap_elem_to_freelist (bitmap head, bitmap_element *elt)
+{
+ bitmap_obstack *bit_obstack = head->obstack;
+
+ if (bit_obstack)
+ {
+ elt->next = bit_obstack->elements;
+ bit_obstack->elements = elt;
+ }
+ else
+ {
+ elt->next = bitmap_ggc_free;
+ bitmap_ggc_free = elt;
+ }
+}
+
+/* Free a bitmap element. Since these are allocated off the
+ bitmap_obstack, "free" actually means "put onto the freelist". */
+
+static inline void
+bitmap_element_free (bitmap head, bitmap_element *elt)
{
bitmap_element *next = elt->next;
bitmap_element *prev = elt->prev;
/* Since the first thing we try is to insert before current,
make current the next entry in preference to the previous. */
if (head->current == elt)
- head->current = next != 0 ? next : prev;
-
- elt->next = bitmap_free;
- bitmap_free = elt;
+ {
+ head->current = next != 0 ? next : prev;
+ if (head->current)
+ head->indx = head->current->indx;
+ }
+ bitmap_elem_to_freelist (head, elt);
}
\f
/* Allocate a bitmap element. The bits are cleared, but nothing else is. */
-static INLINE bitmap_element *
-bitmap_element_allocate ()
+static inline bitmap_element *
+bitmap_element_allocate (bitmap head)
{
bitmap_element *element;
-#if BITMAP_ELEMENT_WORDS != 2
- int i;
-#endif
-
- if (bitmap_free != 0)
+ bitmap_obstack *bit_obstack = head->obstack;
+
+ if (bit_obstack)
{
- element = bitmap_free;
- bitmap_free = element->next;
+ element = bit_obstack->elements;
+
+ if (element)
+ bit_obstack->elements = element->next;
+ else
+ element = XOBNEW (&bit_obstack->obstack, bitmap_element);
}
else
{
- /* We can't use gcc_obstack_init to initialize the obstack since
- print-rtl.c now calls bitmap functions, and bitmap is linked
- into the gen* functions. */
- if (!bitmap_obstack_init)
- {
- bitmap_obstack_init = TRUE;
+ element = bitmap_ggc_free;
+ if (element)
+ bitmap_ggc_free = element->next;
+ else
+ element = GGC_NEW (bitmap_element);
+ }
- /* Let particular systems override the size of a chunk. */
-#ifndef OBSTACK_CHUNK_SIZE
-#define OBSTACK_CHUNK_SIZE 0
-#endif
- /* Let them override the alloc and free routines too. */
-#ifndef OBSTACK_CHUNK_ALLOC
-#define OBSTACK_CHUNK_ALLOC xmalloc
-#endif
-#ifndef OBSTACK_CHUNK_FREE
-#define OBSTACK_CHUNK_FREE free
-#endif
+ memset (element->bits, 0, sizeof (element->bits));
+
+ return element;
+}
+
+/* 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;
+ }
+}
+
+/* Clear a bitmap by freeing the linked list. */
+
+inline void
+bitmap_clear (bitmap head)
+{
+ bitmap_element *element, *next;
+
+ for (element = head->first; element != 0; element = next)
+ {
+ next = element->next;
+ bitmap_elem_to_freelist (head, element);
+ }
+
+ head->first = head->current = 0;
+}
+\f
+/* Initialize a bitmap obstack. If BIT_OBSTACK is NULL, initialize
+ the default bitmap obstack. */
+
+void
+bitmap_obstack_initialize (bitmap_obstack *bit_obstack)
+{
+ if (!bit_obstack)
+ bit_obstack = &bitmap_default_obstack;
#if !defined(__GNUC__) || (__GNUC__ < 2)
#define __alignof__(type) 0
#endif
- obstack_specify_allocation (&bitmap_obstack, OBSTACK_CHUNK_SIZE,
- __alignof__ (bitmap_element),
- (void *(*) PARAMS ((long))) OBSTACK_CHUNK_ALLOC,
- (void (*) PARAMS ((void *))) OBSTACK_CHUNK_FREE);
- }
+ bit_obstack->elements = NULL;
+ bit_obstack->heads = NULL;
+ obstack_specify_allocation (&bit_obstack->obstack, OBSTACK_CHUNK_SIZE,
+ __alignof__ (bitmap_element),
+ obstack_chunk_alloc,
+ obstack_chunk_free);
+}
- element = (bitmap_element *) obstack_alloc (&bitmap_obstack,
- sizeof (bitmap_element));
- }
+/* Release the memory from a bitmap obstack. If BIT_OBSTACK is NULL,
+ release the default bitmap obstack. */
-#if BITMAP_ELEMENT_WORDS == 2
- element->bits[0] = element->bits[1] = 0;
-#else
- for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
- element->bits[i] = 0;
-#endif
+void
+bitmap_obstack_release (bitmap_obstack *bit_obstack)
+{
+ if (!bit_obstack)
+ bit_obstack = &bitmap_default_obstack;
+
+ bit_obstack->elements = NULL;
+ bit_obstack->heads = NULL;
+ obstack_free (&bit_obstack->obstack, NULL);
+}
- return element;
+/* Create a new bitmap on an obstack. If BIT_OBSTACK is NULL, create
+ it on the default bitmap obstack. */
+
+bitmap
+bitmap_obstack_alloc (bitmap_obstack *bit_obstack)
+{
+ bitmap map;
+
+ if (!bit_obstack)
+ bit_obstack = &bitmap_default_obstack;
+ map = bit_obstack->heads;
+ if (map)
+ bit_obstack->heads = (void *)map->first;
+ else
+ map = XOBNEW (&bit_obstack->obstack, bitmap_head);
+ bitmap_initialize (map, bit_obstack);
+
+ return map;
+}
+
+/* Create a new GCd bitmap. */
+
+bitmap
+bitmap_gc_alloc (void)
+{
+ bitmap map;
+
+ map = GGC_NEW (struct bitmap_head_def);
+ bitmap_initialize (map, NULL);
+
+ return map;
+}
+
+/* Release an obstack allocated bitmap. */
+
+void
+bitmap_obstack_free (bitmap map)
+{
+ if (map)
+ {
+ bitmap_clear (map);
+ map->first = (void *)map->obstack->heads;
+ map->obstack->heads = map;
+ }
}
+\f
/* Return nonzero if all bits in an element are zero. */
-static INLINE int
-bitmap_element_zerop (element)
- bitmap_element *element;
+static inline int
+bitmap_element_zerop (bitmap_element *element)
{
#if BITMAP_ELEMENT_WORDS == 2
return (element->bits[0] | element->bits[1]) == 0;
#else
- int i;
+ unsigned i;
for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
if (element->bits[i] != 0)
\f
/* Link the bitmap element into the current bitmap linked list. */
-static INLINE void
-bitmap_element_link (head, element)
- bitmap head;
- bitmap_element *element;
+static inline void
+bitmap_element_link (bitmap head, bitmap_element *element)
{
unsigned int indx = element->indx;
bitmap_element *ptr;
head->current = element;
head->indx = indx;
}
-\f
-/* Clear a bitmap by freeing the linked list. */
-INLINE void
-bitmap_clear (head)
- bitmap head;
+/* 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 *element, *next;
+ bitmap_element *node = bitmap_element_allocate (head);
- for (element = head->first; element != 0; element = next)
+ if (!elt)
{
- next = element->next;
- element->next = bitmap_free;
- bitmap_free = element;
+ if (!head->current)
+ head->current = node;
+ node->next = head->first;
+ if (node->next)
+ node->next->prev = node;
+ head->first = node;
+ node->prev = NULL;
}
-
- head->first = head->current = 0;
+ else
+ {
+ gcc_assert (head->current);
+ node->next = elt->next;
+ if (node->next)
+ node->next->prev = node;
+ elt->next = node;
+ node->prev = elt;
+ }
+ return node;
}
\f
-/* Copy a bitmap to another bitmap */
+/* Copy a bitmap to another bitmap. */
void
-bitmap_copy (to, from)
- bitmap to;
- bitmap from;
+bitmap_copy (bitmap to, bitmap from)
{
bitmap_element *from_ptr, *to_ptr = 0;
#if BITMAP_ELEMENT_WORDS != 2
- int i;
+ unsigned i;
#endif
bitmap_clear (to);
- /* Copy elements in forward direction one at a time */
+ /* Copy elements in forward direction one at a time. */
for (from_ptr = from->first; from_ptr; from_ptr = from_ptr->next)
{
- bitmap_element *to_elt = bitmap_element_allocate ();
+ bitmap_element *to_elt = bitmap_element_allocate (to);
to_elt->indx = from_ptr->indx;
would hold the bitmap's bit to make eventual allocation
faster. */
-static INLINE bitmap_element *
-bitmap_find_bit (head, bit)
- bitmap head;
- unsigned int bit;
+static inline bitmap_element *
+bitmap_find_bit (bitmap head, unsigned int bit)
{
bitmap_element *element;
- unsigned HOST_WIDE_INT indx = bit / BITMAP_ELEMENT_ALL_BITS;
+ unsigned int indx = bit / BITMAP_ELEMENT_ALL_BITS;
- if (head->current == 0)
- return 0;
+ if (head->current == 0
+ || head->indx == indx)
+ return head->current;
- if (head->indx > indx)
+ if (head->indx < indx)
+ /* INDX is beyond head->indx. Search from head->current
+ forward. */
+ for (element = head->current;
+ element->next != 0 && element->indx < indx;
+ element = element->next)
+ ;
+
+ else if (head->indx / 2 < indx)
+ /* INDX is less than head->indx and closer to head->indx than to
+ 0. Search from head->current backward. */
for (element = head->current;
element->prev != 0 && element->indx > indx;
element = element->prev)
;
else
- for (element = head->current;
+ /* INDX is less than head->indx and closer to 0 than to
+ head->indx. Search from head->first forward. */
+ for (element = head->first;
element->next != 0 && element->indx < indx;
element = element->next)
;
/* Clear a single bit in a bitmap. */
void
-bitmap_clear_bit (head, bit)
- bitmap head;
- int bit;
+bitmap_clear_bit (bitmap head, int bit)
{
bitmap_element *ptr = bitmap_find_bit (head, bit);
if (ptr != 0)
{
- unsigned bit_num = bit % (unsigned) HOST_BITS_PER_WIDE_INT;
- unsigned word_num = ((bit / (unsigned) HOST_BITS_PER_WIDE_INT)
- % BITMAP_ELEMENT_WORDS);
- ptr->bits[word_num] &= ~ (((unsigned HOST_WIDE_INT) 1) << bit_num);
+ unsigned bit_num = bit % BITMAP_WORD_BITS;
+ unsigned word_num = bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
+ ptr->bits[word_num] &= ~ (((BITMAP_WORD) 1) << bit_num);
- /* If we cleared the entire word, free up the element */
+ /* If we cleared the entire word, free up the element. */
if (bitmap_element_zerop (ptr))
bitmap_element_free (head, ptr);
}
}
-\f
/* Set a single bit in a bitmap. */
void
-bitmap_set_bit (head, bit)
- bitmap head;
- int bit;
+bitmap_set_bit (bitmap head, int bit)
{
bitmap_element *ptr = bitmap_find_bit (head, bit);
- unsigned word_num
- = ((bit / (unsigned) HOST_BITS_PER_WIDE_INT) % BITMAP_ELEMENT_WORDS);
- unsigned bit_num = bit % (unsigned) HOST_BITS_PER_WIDE_INT;
- unsigned HOST_WIDE_INT bit_val = ((unsigned HOST_WIDE_INT) 1) << bit_num;
+ unsigned word_num = bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
+ unsigned bit_num = bit % BITMAP_WORD_BITS;
+ BITMAP_WORD bit_val = ((BITMAP_WORD) 1) << bit_num;
if (ptr == 0)
{
- ptr = bitmap_element_allocate ();
+ ptr = bitmap_element_allocate (head);
ptr->indx = bit / BITMAP_ELEMENT_ALL_BITS;
ptr->bits[word_num] = bit_val;
bitmap_element_link (head, ptr);
else
ptr->bits[word_num] |= bit_val;
}
-\f
+
/* Return whether a bit is set within a bitmap. */
int
-bitmap_bit_p (head, bit)
- bitmap head;
- int bit;
+bitmap_bit_p (bitmap head, int bit)
{
bitmap_element *ptr;
unsigned bit_num;
if (ptr == 0)
return 0;
- bit_num = bit % (unsigned) HOST_BITS_PER_WIDE_INT;
- word_num
- = ((bit / (unsigned) HOST_BITS_PER_WIDE_INT) % BITMAP_ELEMENT_WORDS);
+ bit_num = bit % BITMAP_WORD_BITS;
+ word_num = bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
return (ptr->bits[word_num] >> bit_num) & 1;
}
\f
-/* Store in bitmap TO the result of combining bitmap FROM1 and FROM2 using
- a specific bit manipulation. Return true if TO changes. */
+/* Return the bit number of the first set bit in the bitmap. The
+ bitmap must be non-empty. */
-int
-bitmap_operation (to, from1, from2, operation)
- bitmap to;
- bitmap from1;
- bitmap from2;
- enum bitmap_bits operation;
-{
- bitmap_element *from1_ptr = from1->first;
- bitmap_element *from2_ptr = from2->first;
- unsigned int indx1 = (from1_ptr) ? from1_ptr->indx : -1;
- unsigned int indx2 = (from2_ptr) ? from2_ptr->indx : -1;
- bitmap_element *to_ptr = to->first;
- bitmap_element *from1_tmp;
- bitmap_element *from2_tmp;
- bitmap_element *to_tmp;
- unsigned int indx;
- int changed = 0;
+unsigned
+bitmap_first_set_bit (bitmap a)
+{
+ bitmap_element *elt = a->first;
+ unsigned bit_no;
+ BITMAP_WORD word;
+ unsigned ix;
+
+ gcc_assert (elt);
+ bit_no = elt->indx * BITMAP_ELEMENT_ALL_BITS;
+ for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++)
+ {
+ word = elt->bits[ix];
+ if (word)
+ goto found_bit;
+ }
+ gcc_unreachable ();
+ found_bit:
+ bit_no += ix * BITMAP_WORD_BITS;
-#if BITMAP_ELEMENT_WORDS == 2
-#define DOIT(OP) \
- do { \
- unsigned HOST_WIDE_INT 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)
+#if GCC_VERSION >= 3004
+ gcc_assert (sizeof(long) == sizeof (word));
+ bit_no += __builtin_ctzl (word);
#else
-#define DOIT(OP) \
- do { \
- unsigned HOST_WIDE_INT 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)
+ /* Binary search for the first set bit. */
+#if BITMAP_WORD_BITS > 64
+#error "Fill out the table."
+#endif
+#if BITMAP_WORD_BITS > 32
+ if (!(word & 0xffffffff))
+ word >>= 32, bit_no += 32;
#endif
+ if (!(word & 0xffff))
+ word >>= 16, bit_no += 16;
+ if (!(word & 0xff))
+ word >>= 8, bit_no += 8;
+ if (!(word & 0xf))
+ word >>= 4, bit_no += 4;
+ if (!(word & 0x3))
+ word >>= 2, bit_no += 2;
+ if (!(word & 0x1))
+ word >>= 1, bit_no += 1;
+
+ gcc_assert (word & 1);
+#endif
+ return bit_no;
+}
+\f
- to->first = to->current = 0;
+/* DST = A & B. */
- while (from1_ptr != 0 || from2_ptr != 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;
+
+ 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 : -1;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : -1;
+ /* 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;
- from1_ptr = from1_ptr->next;
- indx1 = (from1_ptr) ? from1_ptr->indx : -1;
+ 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;
- from2_tmp = from2_ptr;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : -1;
+ /* 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);
+}
- /* Find the appropriate element from TO. Begin by discarding
- elements that we've skipped. */
- while (to_ptr && to_ptr->indx < 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;
+
+ 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;
- to_tmp->next = bitmap_free;
- bitmap_free = 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 ();
+ {
+ /* Matching elts, generate A &= ~B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
- /* Do the operation, and if any bits are set, link it into the
- linked list. */
- switch (operation)
+ 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);
+}
+
+/* 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)
+ {
+ /* 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
{
- default:
- abort ();
+ /* Copy a single element. */
+ bitmap_element *src;
- case BITMAP_AND:
- DOIT (&);
- break;
+ 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;
+ }
- case BITMAP_AND_COMPL:
- DOIT (&~);
- break;
+ 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;
+ }
+ }
- case BITMAP_IOR:
- DOIT (|);
- break;
+ 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;
+}
- case BITMAP_XOR:
- DOIT (^);
- break;
+/* 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)
+ {
+ a_prev = a_elt;
+ a_elt = a_elt->next;
+ }
+ else
+ {
+ /* 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;
+}
+
+/* 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;
- if (! bitmap_element_zerop (to_tmp))
+ gcc_assert (dst != a && dst != b && a != b);
+ while (a_elt || b_elt)
+ {
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
{
- to_tmp->indx = indx;
- bitmap_element_link (to, to_tmp);
+ /* 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_free;
- bitmap_free = to_tmp;
+ /* 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;
+}
+
+/* A ^= B */
- /* If we have elements of TO left over, free the lot. */
- if (to_ptr)
+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)
{
- changed = 1;
- for (to_tmp = to_ptr; to_tmp->next ; to_tmp = to_tmp->next)
- continue;
- to_tmp->next = bitmap_free;
- bitmap_free = to_ptr;
+ 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;
+}
-#undef DOIT
+/* Return true if two bitmaps are identical.
+ We do not bother with a check for pointer equality, as that never
+ occurs in practice. */
- return changed;
+bool
+bitmap_equal_p (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt;
+ bitmap_element *b_elt;
+ unsigned ix;
+
+ for (a_elt = a->first, b_elt = b->first;
+ a_elt && b_elt;
+ a_elt = a_elt->next, b_elt = b_elt->next)
+ {
+ if (a_elt->indx != b_elt->indx)
+ return false;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ if (a_elt->bits[ix] != b_elt->bits[ix])
+ return false;
+ }
+ return !a_elt && !b_elt;
}
-/* Return true if two bitmaps are identical. */
+/* Return true if A AND B is not empty. */
-int
-bitmap_equal_p (a, b)
- bitmap a;
- bitmap b;
+bool
+bitmap_intersect_p (bitmap a, bitmap b)
{
- bitmap_head c;
- int ret;
+ bitmap_element *a_elt;
+ bitmap_element *b_elt;
+ unsigned ix;
+
+ for (a_elt = a->first, b_elt = b->first;
+ 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
+ {
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ if (a_elt->bits[ix] & b_elt->bits[ix])
+ return true;
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ }
+ }
+ return false;
+}
- c.first = c.current = 0;
- ret = ! bitmap_operation (&c, a, b, BITMAP_XOR);
- bitmap_clear (&c);
+/* Return true if A AND NOT B is not empty. */
- return ret;
+bool
+bitmap_intersect_compl_p (bitmap a, bitmap b)
+{
+ bitmap_element *a_elt;
+ bitmap_element *b_elt;
+ unsigned ix;
+ for (a_elt = a->first, b_elt = b->first;
+ a_elt && b_elt;)
+ {
+ if (a_elt->indx < b_elt->indx)
+ return true;
+ else if (b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
+ else
+ {
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ if (a_elt->bits[ix] & ~b_elt->bits[ix])
+ return true;
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ }
+ }
+ return a_elt != NULL;
}
+
\f
-/* Or into bitmap TO bitmap FROM1 and'ed with the complement of
- bitmap FROM2. */
+/* DST = A | (FROM1 & ~FROM2). Return true if DST changes. */
-void
-bitmap_ior_and_compl (to, from1, from2)
- bitmap to;
- bitmap from1;
- bitmap from2;
+bool
+bitmap_ior_and_compl (bitmap dst, bitmap a, bitmap from1, bitmap from2)
{
bitmap_head tmp;
+ bool changed;
- tmp.first = tmp.current = 0;
-
- bitmap_operation (&tmp, from1, from2, BITMAP_AND_COMPL);
- bitmap_operation (to, to, &tmp, BITMAP_IOR);
+ bitmap_initialize (&tmp, &bitmap_default_obstack);
+ bitmap_and_compl (&tmp, from1, from2);
+ changed = bitmap_ior (dst, a, &tmp);
bitmap_clear (&tmp);
+
+ return changed;
}
-\f
-/* Initialize a bitmap header. */
-bitmap
-bitmap_initialize (head)
- bitmap head;
+/* A |= (FROM1 & ~FROM2). Return true if A changes. */
+
+bool
+bitmap_ior_and_compl_into (bitmap a, bitmap from1, bitmap from2)
{
- head->first = head->current = 0;
+ bitmap_head tmp;
+ bool changed;
+
+ bitmap_initialize (&tmp, &bitmap_default_obstack);
+ bitmap_and_compl (&tmp, from1, from2);
+ changed = bitmap_ior_into (a, &tmp);
+ bitmap_clear (&tmp);
- return head;
+ return changed;
}
\f
/* Debugging function to print out the contents of a bitmap. */
void
-debug_bitmap_file (file, head)
- FILE *file;
- bitmap head;
+debug_bitmap_file (FILE *file, bitmap head)
{
bitmap_element *ptr;
- fprintf (file, "\nfirst = ");
- fprintf (file, HOST_PTR_PRINTF, head->first);
- fprintf (file, " current = ");
- fprintf (file, HOST_PTR_PRINTF, head->current);
- fprintf (file, " indx = %u\n", head->indx);
+ fprintf (file, "\nfirst = " HOST_PTR_PRINTF
+ " current = " HOST_PTR_PRINTF " indx = %u\n",
+ (void *) head->first, (void *) head->current, head->indx);
for (ptr = head->first; ptr; ptr = ptr->next)
{
- int i, j, col = 26;
+ unsigned int i, j, col = 26;
- fprintf (file, "\t");
- fprintf (file, HOST_PTR_PRINTF, ptr);
- fprintf (file, " next = ");
- fprintf (file, HOST_PTR_PRINTF, ptr->next);
- fprintf (file, " prev = ");
- fprintf (file, HOST_PTR_PRINTF, ptr->prev);
- fprintf (file, " indx = %u\n\t\tbits = {", ptr->indx);
+ fprintf (file, "\t" HOST_PTR_PRINTF " next = " HOST_PTR_PRINTF
+ " prev = " HOST_PTR_PRINTF " indx = %u\n\t\tbits = {",
+ (void*) ptr, (void*) ptr->next, (void*) ptr->prev, ptr->indx);
for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
- for (j = 0; j < HOST_BITS_PER_WIDE_INT; j++)
+ for (j = 0; j < BITMAP_WORD_BITS; j++)
if ((ptr->bits[i] >> j) & 1)
{
if (col > 70)
}
fprintf (file, " %u", (ptr->indx * BITMAP_ELEMENT_ALL_BITS
- + i * HOST_BITS_PER_WIDE_INT + j));
+ + i * BITMAP_WORD_BITS + j));
col += 4;
}
fprintf (file, " }\n");
}
}
-\f
+
/* Function to be called from the debugger to print the contents
of a bitmap. */
void
-debug_bitmap (head)
- bitmap head;
+debug_bitmap (bitmap head)
{
debug_bitmap_file (stdout, head);
}
-\f
+
/* Function to print out the contents of a bitmap. Unlike debug_bitmap_file,
it does not print anything but the bits. */
void
-bitmap_print (file, head, prefix, suffix)
- FILE *file;
- bitmap head;
- const char *prefix;
- const char *suffix;
+bitmap_print (FILE *file, bitmap head, const char *prefix, const char *suffix)
{
const char *comma = "";
- int i;
+ unsigned i;
+ bitmap_iterator bi;
fputs (prefix, file);
- EXECUTE_IF_SET_IN_BITMAP (head, 0, i,
- {
- fprintf (file, "%s%d", comma, i);
- comma = ", ";
- });
- fputs (suffix, file);
-}
-\f
-/* Release any memory allocated by bitmaps. */
-
-void
-bitmap_release_memory ()
-{
- bitmap_free = 0;
- if (bitmap_obstack_init)
+ EXECUTE_IF_SET_IN_BITMAP (head, 0, i, bi)
{
- bitmap_obstack_init = FALSE;
- obstack_free (&bitmap_obstack, NULL_PTR);
+ fprintf (file, "%s%d", comma, i);
+ comma = ", ";
}
+ fputs (suffix, file);
}
+
+#include "gt-bitmap.h"