/* Functions to support general ended bitmaps.
- Copyright (C) 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
+ 2006, 2007 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 3, 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 COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
#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"
+#include "ggc.h"
+#include "bitmap.h"
+#include "hashtab.h"
-/* Obstack to allocate bitmap elements from. */
-static struct obstack bitmap_obstack;
-static int bitmap_obstack_init = FALSE;
+#ifdef GATHER_STATISTICS
-\f
-#ifndef INLINE
-#ifndef __GNUC__
-#define INLINE
-#else
-#define INLINE __inline__
-#endif
+/* Store information about each particular bitmap. */
+struct bitmap_descriptor
+{
+ const char *function;
+ const char *file;
+ int line;
+ int allocated;
+ int created;
+ int peak;
+ int current;
+ int nsearches;
+};
+
+/* Hashtable mapping bitmap names to descriptors. */
+static htab_t bitmap_desc_hash;
+
+/* Hashtable helpers. */
+static hashval_t
+hash_descriptor (const void *p)
+{
+ const struct bitmap_descriptor *const d = p;
+ return htab_hash_pointer (d->file) + d->line;
+}
+struct loc
+{
+ const char *file;
+ const char *function;
+ int line;
+};
+static int
+eq_descriptor (const void *p1, const void *p2)
+{
+ const struct bitmap_descriptor *const d = p1;
+ const struct loc *const l = p2;
+ return d->file == l->file && d->function == l->function && d->line == l->line;
+}
+
+/* For given file and line, return descriptor, create new if needed. */
+static struct bitmap_descriptor *
+bitmap_descriptor (const char *file, const char *function, int line)
+{
+ struct bitmap_descriptor **slot;
+ struct loc loc;
+
+ loc.file = file;
+ loc.function = function;
+ loc.line = line;
+
+ if (!bitmap_desc_hash)
+ bitmap_desc_hash = htab_create (10, hash_descriptor, eq_descriptor, NULL);
+
+ slot = (struct bitmap_descriptor **)
+ htab_find_slot_with_hash (bitmap_desc_hash, &loc,
+ htab_hash_pointer (file) + line,
+ 1);
+ if (*slot)
+ return *slot;
+ *slot = xcalloc (sizeof (**slot), 1);
+ (*slot)->file = file;
+ (*slot)->function = function;
+ (*slot)->line = line;
+ return *slot;
+}
+
+/* Register new bitmap. */
+void
+bitmap_register (bitmap b MEM_STAT_DECL)
+{
+ b->desc = bitmap_descriptor (_loc_name, _loc_function, _loc_line);
+ b->desc->created++;
+}
+
+/* Account the overhead. */
+static void
+register_overhead (bitmap b, int amount)
+{
+ b->desc->current += amount;
+ if (amount > 0)
+ b->desc->allocated += amount;
+ gcc_assert (b->desc->current >= 0);
+ if (b->desc->peak < b->desc->current)
+ b->desc->peak = b->desc->current;
+}
#endif
/* 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 PROTO((bitmap, bitmap_element *));
-static bitmap_element *bitmap_element_allocate PROTO((void));
-static int bitmap_element_zerop PROTO((bitmap_element *));
-static void bitmap_element_link PROTO((bitmap, bitmap_element *));
-static bitmap_element *bitmap_find_bit PROTO((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 (const bitmap_element *);
+static void bitmap_element_link (bitmap, bitmap_element *);
+static bitmap_element *bitmap_elt_insert_after (bitmap, bitmap_element *, unsigned int);
+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;
+
+ elt->next = NULL;
+ if (bit_obstack)
+ {
+ elt->prev = bit_obstack->elements;
+ bit_obstack->elements = elt;
+ }
+ else
+ {
+ elt->prev = 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;
+ else
+ head->indx = 0;
+ }
+#ifdef GATHER_STATISTICS
+ register_overhead (head, -((int)sizeof (bitmap_element)));
+#endif
+ 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
+ bitmap_obstack *bit_obstack = head->obstack;
- if (bitmap_free != 0)
+ if (bit_obstack)
{
- element = bitmap_free;
- bitmap_free = element->next;
+ element = bit_obstack->elements;
+
+ if (element)
+ /* Use up the inner list first before looking at the next
+ element of the outer list. */
+ if (element->next)
+ {
+ bit_obstack->elements = element->next;
+ bit_obstack->elements->prev = element->prev;
+ }
+ else
+ /* Inner list was just a singleton. */
+ bit_obstack->elements = element->prev;
+ 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)
+ /* Use up the inner list first before looking at the next
+ element of the outer list. */
+ if (element->next)
+ {
+ bitmap_ggc_free = element->next;
+ bitmap_ggc_free->prev = element->prev;
+ }
+ else
+ /* Inner list was just a singleton. */
+ bitmap_ggc_free = element->prev;
+ else
+ element = GGC_NEW (bitmap_element);
+ }
- /* Let particular systems override the size of a chunk. */
-#ifndef OBSTACK_CHUNK_SIZE
-#define OBSTACK_CHUNK_SIZE 0
+#ifdef GATHER_STATISTICS
+ register_overhead (head, sizeof (bitmap_element));
#endif
- /* Let them override the alloc and free routines too. */
-#ifndef OBSTACK_CHUNK_ALLOC
-#define OBSTACK_CHUNK_ALLOC xmalloc
+ 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 *prev;
+ bitmap_obstack *bit_obstack = head->obstack;
+#ifdef GATHER_STATISTICS
+ int n;
#endif
-#ifndef OBSTACK_CHUNK_FREE
-#define OBSTACK_CHUNK_FREE free
+
+ if (!elt) return;
+#ifdef GATHER_STATISTICS
+ n = 0;
+ for (prev = elt; prev; prev = prev->next)
+ n++;
+ register_overhead (head, -sizeof (bitmap_element) * n);
#endif
+ prev = elt->prev;
+ if (prev)
+ {
+ prev->next = NULL;
+ if (head->current->indx > prev->indx)
+ {
+ head->current = prev;
+ head->indx = prev->indx;
+ }
+ }
+ else
+ {
+ head->first = NULL;
+ head->current = NULL;
+ head->indx = 0;
+ }
+
+ /* Put the entire list onto the free list in one operation. */
+ if (bit_obstack)
+ {
+ elt->prev = bit_obstack->elements;
+ bit_obstack->elements = elt;
+ }
+ else
+ {
+ elt->prev = bitmap_ggc_free;
+ bitmap_ggc_free = elt;
+ }
+}
+
+/* Clear a bitmap by freeing the linked list. */
+
+inline void
+bitmap_clear (bitmap head)
+{
+ if (head->first)
+ bitmap_elt_clear_from (head, head->first);
+}
+\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 *(*) ()) OBSTACK_CHUNK_ALLOC,
- (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;
+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);
+}
+
+/* Create a new bitmap on an obstack. If BIT_OBSTACK is NULL, create
+ it on the default bitmap obstack. */
+
+bitmap
+bitmap_obstack_alloc_stat (bitmap_obstack *bit_obstack MEM_STAT_DECL)
+{
+ 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_stat (map, bit_obstack PASS_MEM_STAT);
+#ifdef GATHER_STATISTICS
+ register_overhead (map, sizeof (bitmap_head));
#endif
- return element;
+ return map;
+}
+
+/* Create a new GCd bitmap. */
+
+bitmap
+bitmap_gc_alloc_stat (ALONE_MEM_STAT_DECL)
+{
+ bitmap map;
+
+ map = GGC_NEW (struct bitmap_head_def);
+ bitmap_initialize_stat (map, NULL PASS_MEM_STAT);
+#ifdef GATHER_STATISTICS
+ register_overhead (map, sizeof (bitmap_head));
+#endif
+
+ return map;
+}
+
+/* Release an obstack allocated bitmap. */
+
+void
+bitmap_obstack_free (bitmap map)
+{
+ if (map)
+ {
+ bitmap_clear (map);
+ map->first = (void *)map->obstack->heads;
+#ifdef GATHER_STATISTICS
+ register_overhead (map, -((int)sizeof (bitmap_head)));
+#endif
+ 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 (const 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, unsigned int indx)
{
- bitmap_element *element, *next;
+ bitmap_element *node = bitmap_element_allocate (head);
+ node->indx = indx;
- 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;
+ head->indx = indx;
+ }
+ 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, const_bitmap from)
{
- bitmap_element *from_ptr, *to_ptr = 0;
-#if BITMAP_ELEMENT_WORDS != 2
- int i;
-#endif
+ const bitmap_element *from_ptr;
+ bitmap_element *to_ptr = 0;
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;
-
-#if BITMAP_ELEMENT_WORDS == 2
- to_elt->bits[0] = from_ptr->bits[0];
- to_elt->bits[1] = from_ptr->bits[1];
-#else
- for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
- to_elt->bits[i] = from_ptr->bits[i];
-#endif
+ memcpy (to_elt->bits, from_ptr->bits, sizeof (to_elt->bits));
/* Here we have a special case of bitmap_element_link, for the case
where we know the links are being entered in sequence. */
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;
+#ifdef GATHER_STATISTICS
+ head->desc->nsearches++;
+#endif
+ if (head->current == 0
+ || head->indx == indx)
+ return head->current;
+
+ 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)
+ ;
- if (head->indx > indx)
+ 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);
+ bitmap_element *const 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] & (((unsigned HOST_WIDE_INT) 1) << bit_num)) != 0;
+ 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. */
+#if GCC_VERSION < 3400
+/* Table of number of set bits in a character, indexed by value of char. */
+static const unsigned char popcount_table[] =
+{
+ 0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
+ 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+ 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+ 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+ 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
+ 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+ 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
+ 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8,
+};
+
+static unsigned long
+bitmap_popcount (BITMAP_WORD a)
+{
+ unsigned long ret = 0;
+ unsigned i;
-void
-bitmap_operation (to, from1, from2, operation)
- bitmap to;
- bitmap from1;
- bitmap from2;
- enum bitmap_bits operation;
-{
- bitmap_element *delete_list = 0;
- bitmap_element *from1_ptr = from1->first;
- bitmap_element *from2_ptr = from2->first;
- unsigned int indx1
- = (from1_ptr) ? from1_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
- unsigned int indx2
- = (from2_ptr) ? from2_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
- bitmap_element *to_ptr = 0;
- bitmap_element *from1_tmp;
- bitmap_element *from2_tmp;
- unsigned int indx;
-#if BITMAP_ELEMENT_WORDS != 2
- int i;
+ /* Just do this the table way for now */
+ for (i = 0; i < BITMAP_WORD_BITS; i+= 8)
+ ret += popcount_table[(a >> i) & 0xff];
+ return ret;
+}
#endif
+/* Count the number of bits set in the bitmap, and return it. */
- /* To simplify things, always create a new list. If the old list was one
- of the inputs, free it later. Otherwise, free it now. */
- if (to == from1 || to == from2)
- {
- delete_list = to->first;
- to->first = to->current = 0;
- }
- else
- bitmap_clear (to);
+unsigned long
+bitmap_count_bits (const_bitmap a)
+{
+ unsigned long count = 0;
+ const bitmap_element *elt;
+ unsigned ix;
- while (from1_ptr != 0 || from2_ptr != 0)
+ for (elt = a->first; elt; elt = elt->next)
{
- /* Figure out whether we need to substitute zero elements for
- missing links. */
- if (indx1 == indx2)
- {
- indx = indx1;
- from1_tmp = from1_ptr;
- from2_tmp = from2_ptr;
- from1_ptr = from1_ptr->next;
- indx1 = (from1_ptr) ? from1_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
- }
- else if (indx1 < indx2)
- {
- indx = indx1;
- from1_tmp = from1_ptr;
- from2_tmp = &bitmap_zero;
- from1_ptr = from1_ptr->next;
- indx1 = (from1_ptr) ? from1_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
- }
- else
+ for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++)
{
- indx = indx2;
- from1_tmp = &bitmap_zero;
- from2_tmp = from2_ptr;
- from2_ptr = from2_ptr->next;
- indx2 = (from2_ptr) ? from2_ptr->indx : ~ (unsigned HOST_WIDE_INT) 0;
+#if GCC_VERSION >= 3400
+ /* Note that popcountl matches BITMAP_WORD in type, so the actual size
+ of BITMAP_WORD is not material. */
+ count += __builtin_popcountl (elt->bits[ix]);
+#else
+ count += bitmap_popcount (elt->bits[ix]);
+#endif
}
+ }
+ return count;
+}
- if (to_ptr == 0)
- to_ptr = bitmap_element_allocate ();
- /* Do the operation, and if any bits are set, link it into the
- linked list. */
- switch (operation)
- {
- default:
- abort ();
- case BITMAP_AND:
-#if BITMAP_ELEMENT_WORDS == 2
- to_ptr->bits[0] = from1_tmp->bits[0] & from2_tmp->bits[0];
- to_ptr->bits[1] = from1_tmp->bits[1] & from2_tmp->bits[1];
-#else
- for (i = BITMAP_ELEMENT_WORDS - 1; i >= 0; i--)
- to_ptr->bits[i] = from1_tmp->bits[i] & from2_tmp->bits[i];
-#endif
- break;
+/* Return the bit number of the first set bit in the bitmap. The
+ bitmap must be non-empty. */
- case BITMAP_AND_COMPL:
-#if BITMAP_ELEMENT_WORDS == 2
- to_ptr->bits[0] = from1_tmp->bits[0] & ~ from2_tmp->bits[0];
- to_ptr->bits[1] = from1_tmp->bits[1] & ~ from2_tmp->bits[1];
-#else
- for (i = BITMAP_ELEMENT_WORDS - 1; i >= 0; i--)
- to_ptr->bits[i] = from1_tmp->bits[i] & ~ from2_tmp->bits[i];
-#endif
- break;
+unsigned
+bitmap_first_set_bit (const_bitmap a)
+{
+ const 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;
- case BITMAP_IOR:
-#if BITMAP_ELEMENT_WORDS == 2
- to_ptr->bits[0] = from1_tmp->bits[0] | from2_tmp->bits[0];
- to_ptr->bits[1] = from1_tmp->bits[1] | from2_tmp->bits[1];
+#if GCC_VERSION >= 3004
+ gcc_assert (sizeof(long) == sizeof (word));
+ bit_no += __builtin_ctzl (word);
#else
- for (i = BITMAP_ELEMENT_WORDS - 1; i >= 0; i--)
- to_ptr->bits[i] = from1_tmp->bits[i] | from2_tmp->bits[i];
+ /* Binary search for the first set bit. */
+#if BITMAP_WORD_BITS > 64
+#error "Fill out the table."
#endif
- break;
- }
+#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
- if (! bitmap_element_zerop (to_ptr))
- {
- to_ptr->indx = indx;
- bitmap_element_link (to, to_ptr);
- to_ptr = 0;
- }
- }
+/* DST = A & B. */
+
+void
+bitmap_and (bitmap dst, const_bitmap a, const_bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ const bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+
+ gcc_assert (dst != a && dst != b);
- /* If we have an unallocated element due to the last element being 0,
- release it back to the free pool. Don't bother calling
- bitmap_element_free since it was never linked into a bitmap. */
- if (to_ptr != 0)
+ if (a == b)
{
- to_ptr->next = bitmap_free;
- bitmap_free = to_ptr;
+ bitmap_copy (dst, a);
+ return;
}
- /* If the output bitmap was one of the inputs, free up its
- elements now that we're done. */
- for (; delete_list != 0; delete_list = to_ptr)
+ while (a_elt && b_elt)
{
- to_ptr = delete_list->next;
- delete_list->next = bitmap_free;
- bitmap_free = delete_list;
+ 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
+ {
+ /* Matching elts, generate A & B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev, a_elt->indx);
+ else
+ 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;
+ }
}
+ /* Ensure that dst->current is valid. */
+ dst->current = dst->first;
+ bitmap_elt_clear_from (dst, dst_elt);
+ gcc_assert (!dst->current == !dst->first);
+ if (dst->current)
+ dst->indx = dst->current->indx;
}
-\f
-/* Or into bitmap TO bitmap FROM1 and'ed with the complement of
- bitmap FROM2. */
+
+/* A &= B. */
void
-bitmap_ior_and_compl (to, from1, from2)
- bitmap to;
- bitmap from1;
- bitmap from2;
+bitmap_and_into (bitmap a, const_bitmap b)
{
- bitmap_head tmp;
+ bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *next;
- tmp.first = tmp.current = 0;
+ if (a == b)
+ return;
- bitmap_operation (&tmp, from1, from2, BITMAP_AND_COMPL);
- bitmap_operation (to, to, &tmp, BITMAP_IOR);
- bitmap_clear (&tmp);
+ while (a_elt && b_elt)
+ {
+ if (a_elt->indx < b_elt->indx)
+ {
+ 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
+ {
+ /* 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);
}
-\f
-/* Initialize a bitmap header. */
-bitmap
-bitmap_initialize (head)
- bitmap head;
-{
- head->first = head->current = 0;
- return head;
+/* Insert an element equal to SRC_ELT after DST_PREV, overwriting DST_ELT
+ if non-NULL. CHANGED is true if the destination bitmap had already been
+ changed; the new value of CHANGED is returned. */
+
+static inline bool
+bitmap_elt_copy (bitmap dst, bitmap_element *dst_elt, bitmap_element *dst_prev,
+ const bitmap_element *src_elt, bool changed)
+{
+ if (!changed && dst_elt && dst_elt->indx == src_elt->indx)
+ {
+ unsigned ix;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ if (src_elt->bits[ix] != dst_elt->bits[ix])
+ {
+ dst_elt->bits[ix] = src_elt->bits[ix];
+ changed = true;
+ }
+ }
+ else
+ {
+ changed = true;
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev, src_elt->indx);
+ else
+ dst_elt->indx = src_elt->indx;
+ memcpy (dst_elt->bits, src_elt->bits, sizeof (dst_elt->bits));
+ }
+ return changed;
}
-\f
-/* Debugging function to print out the contents of a bitmap. */
-void
-bitmap_debug_file (file, head)
- FILE *file;
- bitmap head;
+
+
+/* DST = A & ~B */
+
+bool
+bitmap_and_compl (bitmap dst, const_bitmap a, const_bitmap b)
{
- bitmap_element *ptr;
+ bitmap_element *dst_elt = dst->first;
+ const bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+ bitmap_element **dst_prev_pnext = &dst->first;
+ bool changed = false;
- 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);
+ gcc_assert (dst != a && dst != b);
- for (ptr = head->first; ptr; ptr = ptr->next)
+ if (a == b)
+ {
+ changed = !bitmap_empty_p (dst);
+ bitmap_clear (dst);
+ return changed;
+ }
+
+ while (a_elt)
{
- int i, j, col = 26;
+ while (b_elt && b_elt->indx < a_elt->indx)
+ b_elt = b_elt->next;
- 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);
+ if (!b_elt || b_elt->indx > a_elt->indx)
+ {
+ changed = bitmap_elt_copy (dst, dst_elt, dst_prev, a_elt, changed);
+ dst_prev = *dst_prev_pnext;
+ dst_prev_pnext = &dst_prev->next;
+ dst_elt = *dst_prev_pnext;
+ a_elt = a_elt->next;
+ }
- for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
- for (j = 0; j < HOST_BITS_PER_WIDE_INT; j++)
- if ((ptr->bits[i] & (((unsigned HOST_WIDE_INT) 1) << j)) != 0)
+ else
+ {
+ /* Matching elts, generate A & ~B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!changed && dst_elt && dst_elt->indx == a_elt->indx)
{
- if (col > 70)
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
{
- fprintf (file, "\n\t\t\t");
- col = 24;
+ BITMAP_WORD r = a_elt->bits[ix] & ~b_elt->bits[ix];
+
+ if (dst_elt->bits[ix] != r)
+ {
+ changed = true;
+ dst_elt->bits[ix] = r;
+ }
+ ior |= r;
+ }
+ }
+ else
+ {
+ bool new_element;
+ if (!dst_elt || dst_elt->indx > a_elt->indx)
+ {
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev, a_elt->indx);
+ new_element = true;
+ }
+ else
+ {
+ dst_elt->indx = a_elt->indx;
+ new_element = false;
}
- fprintf (file, " %u", (ptr->indx * BITMAP_ELEMENT_ALL_BITS
- + i * HOST_BITS_PER_WIDE_INT + j));
- col += 4;
+ 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)
+ changed = true;
+ else
+ {
+ changed |= !new_element;
+ bitmap_element_free (dst, dst_elt);
+ dst_elt = *dst_prev_pnext;
+ }
}
- fprintf (file, " }\n");
+ if (ior)
+ {
+ dst_prev = *dst_prev_pnext;
+ dst_prev_pnext = &dst_prev->next;
+ dst_elt = *dst_prev_pnext;
+ }
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ }
}
-}
-\f
-/* Function to be called from the debugger to print the contents
- of a bitmap. */
-void
-debug_bitmap (head)
- bitmap head;
-{
- bitmap_debug_file (stdout, head);
-}
-\f
-/* Function to print out the contents of a bitmap. Unlike bitmap_debug_file,
- it does not print anything but the bits. */
+ /* Ensure that dst->current is valid. */
+ dst->current = dst->first;
+
+ 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. Returns true if A changes */
+
+bool
+bitmap_and_compl_into (bitmap a, const_bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *next;
+ BITMAP_WORD changed = 0;
+
+ if (a == b)
+ {
+ if (bitmap_empty_p (a))
+ return false;
+ else
+ {
+ bitmap_clear (a);
+ return true;
+ }
+ }
+
+ 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
+ {
+ /* Matching elts, generate A &= ~B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD cleared = a_elt->bits[ix] & b_elt->bits[ix];
+ BITMAP_WORD r = a_elt->bits[ix] ^ cleared;
+
+ a_elt->bits[ix] = r;
+ changed |= cleared;
+ 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);
+ return changed != 0;
+}
+
+/* Set COUNT bits from START in HEAD. */
+void
+bitmap_set_range (bitmap head, unsigned int start, unsigned int count)
+{
+ unsigned int first_index, end_bit_plus1, last_index;
+ bitmap_element *elt, *elt_prev;
+ unsigned int i;
+
+ if (!count)
+ return;
+
+ first_index = start / BITMAP_ELEMENT_ALL_BITS;
+ end_bit_plus1 = start + count;
+ last_index = (end_bit_plus1 - 1) / BITMAP_ELEMENT_ALL_BITS;
+ elt = bitmap_find_bit (head, start);
+
+ /* If bitmap_find_bit returns zero, the current is the closest block
+ to the result. Otherwise, just use bitmap_element_allocate to
+ ensure ELT is set; in the loop below, ELT == NULL means "insert
+ at the end of the bitmap". */
+ if (!elt)
+ {
+ elt = bitmap_element_allocate (head);
+ elt->indx = first_index;
+ bitmap_element_link (head, elt);
+ }
+
+ gcc_assert (elt->indx == first_index);
+ elt_prev = elt->prev;
+ for (i = first_index; i <= last_index; i++)
+ {
+ unsigned elt_start_bit = i * BITMAP_ELEMENT_ALL_BITS;
+ unsigned elt_end_bit_plus1 = elt_start_bit + BITMAP_ELEMENT_ALL_BITS;
+
+ unsigned int first_word_to_mod;
+ BITMAP_WORD first_mask;
+ unsigned int last_word_to_mod;
+ BITMAP_WORD last_mask;
+ unsigned int ix;
+
+ if (!elt || elt->indx != i)
+ elt = bitmap_elt_insert_after (head, elt_prev, i);
+
+ if (elt_start_bit <= start)
+ {
+ /* The first bit to turn on is somewhere inside this
+ elt. */
+ first_word_to_mod = (start - elt_start_bit) / BITMAP_WORD_BITS;
+
+ /* This mask should have 1s in all bits >= start position. */
+ first_mask =
+ (((BITMAP_WORD) 1) << ((start % BITMAP_WORD_BITS))) - 1;
+ first_mask = ~first_mask;
+ }
+ else
+ {
+ /* The first bit to turn on is below this start of this elt. */
+ first_word_to_mod = 0;
+ first_mask = ~(BITMAP_WORD) 0;
+ }
+
+ if (elt_end_bit_plus1 <= end_bit_plus1)
+ {
+ /* The last bit to turn on is beyond this elt. */
+ last_word_to_mod = BITMAP_ELEMENT_WORDS - 1;
+ last_mask = ~(BITMAP_WORD) 0;
+ }
+ else
+ {
+ /* The last bit to turn on is inside to this elt. */
+ last_word_to_mod =
+ (end_bit_plus1 - elt_start_bit) / BITMAP_WORD_BITS;
+
+ /* The last mask should have 1s below the end bit. */
+ last_mask =
+ (((BITMAP_WORD) 1) << ((end_bit_plus1 % BITMAP_WORD_BITS))) - 1;
+ }
+
+ if (first_word_to_mod == last_word_to_mod)
+ {
+ BITMAP_WORD mask = first_mask & last_mask;
+ elt->bits[first_word_to_mod] |= mask;
+ }
+ else
+ {
+ elt->bits[first_word_to_mod] |= first_mask;
+ if (BITMAP_ELEMENT_WORDS > 2)
+ for (ix = first_word_to_mod + 1; ix < last_word_to_mod; ix++)
+ elt->bits[ix] = ~(BITMAP_WORD) 0;
+ elt->bits[last_word_to_mod] |= last_mask;
+ }
+
+ elt_prev = elt;
+ elt = elt->next;
+ }
+
+ head->current = elt ? elt : elt_prev;
+ head->indx = head->current->indx;
+}
+
+/* Clear COUNT bits from START in HEAD. */
+void
+bitmap_clear_range (bitmap head, unsigned int start, unsigned int count)
+{
+ unsigned int first_index, end_bit_plus1, last_index;
+ bitmap_element *elt;
+
+ if (!count)
+ return;
+
+ first_index = start / BITMAP_ELEMENT_ALL_BITS;
+ end_bit_plus1 = start + count;
+ last_index = (end_bit_plus1 - 1) / BITMAP_ELEMENT_ALL_BITS;
+ elt = bitmap_find_bit (head, start);
+
+ /* If bitmap_find_bit returns zero, the current is the closest block
+ to the result. If the current is less than first index, find the
+ next one. Otherwise, just set elt to be current. */
+ if (!elt)
+ {
+ if (head->current)
+ {
+ if (head->indx < first_index)
+ {
+ elt = head->current->next;
+ if (!elt)
+ return;
+ }
+ else
+ elt = head->current;
+ }
+ else
+ return;
+ }
+
+ while (elt && (elt->indx <= last_index))
+ {
+ bitmap_element * next_elt = elt->next;
+ unsigned elt_start_bit = (elt->indx) * BITMAP_ELEMENT_ALL_BITS;
+ unsigned elt_end_bit_plus1 = elt_start_bit + BITMAP_ELEMENT_ALL_BITS;
+
+
+ if (elt_start_bit >= start && elt_end_bit_plus1 <= end_bit_plus1)
+ /* Get rid of the entire elt and go to the next one. */
+ bitmap_element_free (head, elt);
+ else
+ {
+ /* Going to have to knock out some bits in this elt. */
+ unsigned int first_word_to_mod;
+ BITMAP_WORD first_mask;
+ unsigned int last_word_to_mod;
+ BITMAP_WORD last_mask;
+ unsigned int i;
+ bool clear = true;
+
+ if (elt_start_bit <= start)
+ {
+ /* The first bit to turn off is somewhere inside this
+ elt. */
+ first_word_to_mod = (start - elt_start_bit) / BITMAP_WORD_BITS;
+
+ /* This mask should have 1s in all bits >= start position. */
+ first_mask =
+ (((BITMAP_WORD) 1) << ((start % BITMAP_WORD_BITS))) - 1;
+ first_mask = ~first_mask;
+ }
+ else
+ {
+ /* The first bit to turn off is below this start of this elt. */
+ first_word_to_mod = 0;
+ first_mask = 0;
+ first_mask = ~first_mask;
+ }
+
+ if (elt_end_bit_plus1 <= end_bit_plus1)
+ {
+ /* The last bit to turn off is beyond this elt. */
+ last_word_to_mod = BITMAP_ELEMENT_WORDS - 1;
+ last_mask = 0;
+ last_mask = ~last_mask;
+ }
+ else
+ {
+ /* The last bit to turn off is inside to this elt. */
+ last_word_to_mod =
+ (end_bit_plus1 - elt_start_bit) / BITMAP_WORD_BITS;
+
+ /* The last mask should have 1s below the end bit. */
+ last_mask =
+ (((BITMAP_WORD) 1) << (((end_bit_plus1) % BITMAP_WORD_BITS))) - 1;
+ }
+
+
+ if (first_word_to_mod == last_word_to_mod)
+ {
+ BITMAP_WORD mask = first_mask & last_mask;
+ elt->bits[first_word_to_mod] &= ~mask;
+ }
+ else
+ {
+ elt->bits[first_word_to_mod] &= ~first_mask;
+ if (BITMAP_ELEMENT_WORDS > 2)
+ for (i = first_word_to_mod + 1; i < last_word_to_mod; i++)
+ elt->bits[i] = 0;
+ elt->bits[last_word_to_mod] &= ~last_mask;
+ }
+ for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
+ if (elt->bits[i])
+ {
+ clear = false;
+ break;
+ }
+ /* Check to see if there are any bits left. */
+ if (clear)
+ bitmap_element_free (head, elt);
+ }
+ elt = next_elt;
+ }
+
+ if (elt)
+ {
+ head->current = elt;
+ head->indx = head->current->indx;
+ }
+}
+
+/* A = ~A & B. */
+
+void
+bitmap_compl_and_into (bitmap a, const_bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *a_prev = NULL;
+ bitmap_element *next;
+
+ gcc_assert (a != b);
+
+ if (bitmap_empty_p (a))
+ {
+ bitmap_copy (a, b);
+ return;
+ }
+ if (bitmap_empty_p (b))
+ {
+ bitmap_clear (a);
+ return;
+ }
+
+ while (a_elt || b_elt)
+ {
+ if (!b_elt || (a_elt && a_elt->indx < b_elt->indx))
+ {
+ /* A is before B. Remove A */
+ next = a_elt->next;
+ a_prev = a_elt->prev;
+ bitmap_element_free (a, a_elt);
+ a_elt = next;
+ }
+ else if (!a_elt || b_elt->indx < a_elt->indx)
+ {
+ /* B is before A. Copy B. */
+ next = bitmap_elt_insert_after (a, a_prev, b_elt->indx);
+ memcpy (next->bits, b_elt->bits, sizeof (next->bits));
+ a_prev = next;
+ b_elt = b_elt->next;
+ }
+ else
+ {
+ /* Matching elts, generate A = ~A & B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD cleared = a_elt->bits[ix] & b_elt->bits[ix];
+ BITMAP_WORD r = b_elt->bits[ix] ^ cleared;
+
+ a_elt->bits[ix] = r;
+ ior |= r;
+ }
+ next = a_elt->next;
+ if (!ior)
+ bitmap_element_free (a, a_elt);
+ else
+ a_prev = 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);
+ return;
+}
+
+
+/* Insert an element corresponding to A_ELT | B_ELT after DST_PREV,
+ overwriting DST_ELT if non-NULL. CHANGED is true if the destination bitmap
+ had already been changed; the new value of CHANGED is returned. */
+
+static inline bool
+bitmap_elt_ior (bitmap dst, bitmap_element *dst_elt, bitmap_element *dst_prev,
+ const bitmap_element *a_elt, const bitmap_element *b_elt,
+ bool changed)
+{
+ gcc_assert (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, a_elt->indx);
+ else
+ 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;
+ }
+ }
+ }
+ else
+ {
+ /* Copy a single element. */
+ const bitmap_element *src;
+
+ if (!b_elt || (a_elt && a_elt->indx < b_elt->indx))
+ src = a_elt;
+ else
+ src = b_elt;
+
+ gcc_assert (src);
+ changed = bitmap_elt_copy (dst, dst_elt, dst_prev, src, changed);
+ }
+ return changed;
+}
+
+
+/* DST = A | B. Return true if DST changes. */
+
+bool
+bitmap_ior (bitmap dst, const_bitmap a, const_bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ const bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+ bitmap_element **dst_prev_pnext = &dst->first;
+ bool changed = false;
+
+ gcc_assert (dst != a && dst != b);
+
+ while (a_elt || b_elt)
+ {
+ changed = bitmap_elt_ior (dst, dst_elt, dst_prev, a_elt, b_elt, changed);
+
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
+ {
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ }
+ else
+ {
+ if (a_elt && (!b_elt || a_elt->indx <= b_elt->indx))
+ a_elt = a_elt->next;
+ else if (b_elt && (!a_elt || b_elt->indx <= a_elt->indx))
+ b_elt = b_elt->next;
+ }
+
+ dst_prev = *dst_prev_pnext;
+ dst_prev_pnext = &dst_prev->next;
+ dst_elt = *dst_prev_pnext;
+ }
+
+ 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, const_bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *a_prev = NULL;
+ bitmap_element **a_prev_pnext = &a->first;
+ bool changed = false;
+
+ if (a == b)
+ return false;
+
+ while (b_elt)
+ {
+ /* If A lags behind B, just advance it. */
+ if (!a_elt || a_elt->indx == b_elt->indx)
+ {
+ changed = bitmap_elt_ior (a, a_elt, a_prev, a_elt, b_elt, changed);
+ b_elt = b_elt->next;
+ }
+ else if (a_elt->indx > b_elt->indx)
+ {
+ changed = bitmap_elt_copy (a, NULL, a_prev, b_elt, changed);
+ b_elt = b_elt->next;
+ }
+
+ a_prev = *a_prev_pnext;
+ a_prev_pnext = &a_prev->next;
+ a_elt = *a_prev_pnext;
+ }
+
+ gcc_assert (!a->current == !a->first);
+ if (a->current)
+ a->indx = a->current->indx;
+ return changed;
+}
+
+/* DST = A ^ B */
+
+void
+bitmap_xor (bitmap dst, const_bitmap a, const_bitmap b)
+{
+ bitmap_element *dst_elt = dst->first;
+ const bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *dst_prev = NULL;
+
+ gcc_assert (dst != a && dst != b);
+ if (a == b)
+ {
+ bitmap_clear (dst);
+ return;
+ }
+
+ while (a_elt || b_elt)
+ {
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
+ {
+ /* Matching elts, generate A ^ B. */
+ unsigned ix;
+ BITMAP_WORD ior = 0;
+
+ if (!dst_elt)
+ dst_elt = bitmap_elt_insert_after (dst, dst_prev, a_elt->indx);
+ else
+ 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
+ {
+ /* Copy a single element. */
+ const 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, src->indx);
+ else
+ dst_elt->indx = src->indx;
+ memcpy (dst_elt->bits, src->bits, sizeof (dst_elt->bits));
+ dst_prev = dst_elt;
+ dst_elt = dst_elt->next;
+ }
+ }
+ /* Ensure that dst->current is valid. */
+ dst->current = dst->first;
+ 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_xor_into (bitmap a, const_bitmap b)
+{
+ bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ bitmap_element *a_prev = NULL;
+
+ if (a == b)
+ {
+ bitmap_clear (a);
+ return;
+ }
+
+ 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, 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.
+ We do not bother with a check for pointer equality, as that never
+ occurs in practice. */
+
+bool
+bitmap_equal_p (const_bitmap a, const_bitmap b)
+{
+ const bitmap_element *a_elt;
+ const 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 A AND B is not empty. */
+
+bool
+bitmap_intersect_p (const_bitmap a, const_bitmap b)
+{
+ const bitmap_element *a_elt;
+ const 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;
+}
+
+/* Return true if A AND NOT B is not empty. */
+
+bool
+bitmap_intersect_compl_p (const_bitmap a, const_bitmap b)
+{
+ const bitmap_element *a_elt;
+ const 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
+/* DST = A | (FROM1 & ~FROM2). Return true if DST changes. */
+
+bool
+bitmap_ior_and_compl (bitmap dst, const_bitmap a, const_bitmap b, const_bitmap kill)
+{
+ bool changed = false;
+
+ bitmap_element *dst_elt = dst->first;
+ const bitmap_element *a_elt = a->first;
+ const bitmap_element *b_elt = b->first;
+ const bitmap_element *kill_elt = kill->first;
+ bitmap_element *dst_prev = NULL;
+ bitmap_element **dst_prev_pnext = &dst->first;
+
+ gcc_assert (dst != a && dst != b && dst != kill);
+
+ /* Special cases. We don't bother checking for bitmap_equal_p (b, kill). */
+ if (b == kill || bitmap_empty_p (b))
+ {
+ changed = !bitmap_equal_p (dst, a);
+ if (changed)
+ bitmap_copy (dst, a);
+ return changed;
+ }
+ if (bitmap_empty_p (kill))
+ return bitmap_ior (dst, a, b);
+ if (bitmap_empty_p (a))
+ return bitmap_and_compl (dst, b, kill);
+
+ while (a_elt || b_elt)
+ {
+ bool new_element = false;
+
+ if (b_elt)
+ while (kill_elt && kill_elt->indx < b_elt->indx)
+ kill_elt = kill_elt->next;
+
+ if (b_elt && kill_elt && kill_elt->indx == b_elt->indx
+ && (!a_elt || a_elt->indx >= b_elt->indx))
+ {
+ bitmap_element tmp_elt;
+ unsigned ix;
+
+ BITMAP_WORD ior = 0;
+ tmp_elt.indx = b_elt->indx;
+ for (ix = BITMAP_ELEMENT_WORDS; ix--;)
+ {
+ BITMAP_WORD r = b_elt->bits[ix] & ~kill_elt->bits[ix];
+ ior |= r;
+ tmp_elt.bits[ix] = r;
+ }
+
+ if (ior)
+ {
+ changed = bitmap_elt_ior (dst, dst_elt, dst_prev,
+ a_elt, &tmp_elt, changed);
+ new_element = true;
+ if (a_elt && a_elt->indx == b_elt->indx)
+ a_elt = a_elt->next;
+ }
+
+ b_elt = b_elt->next;
+ kill_elt = kill_elt->next;
+ }
+ else
+ {
+ changed = bitmap_elt_ior (dst, dst_elt, dst_prev,
+ a_elt, b_elt, changed);
+ new_element = true;
+
+ if (a_elt && b_elt && a_elt->indx == b_elt->indx)
+ {
+ a_elt = a_elt->next;
+ b_elt = b_elt->next;
+ }
+ else
+ {
+ if (a_elt && (!b_elt || a_elt->indx <= b_elt->indx))
+ a_elt = a_elt->next;
+ else if (b_elt && (!a_elt || b_elt->indx <= a_elt->indx))
+ b_elt = b_elt->next;
+ }
+ }
+
+ if (new_element)
+ {
+ dst_prev = *dst_prev_pnext;
+ dst_prev_pnext = &dst_prev->next;
+ dst_elt = *dst_prev_pnext;
+ }
+ }
+
+ 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 |= (FROM1 & ~FROM2). Return true if A changes. */
+
+bool
+bitmap_ior_and_compl_into (bitmap a, const_bitmap from1, const_bitmap from2)
+{
+ 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 changed;
+}
+
+\f
+/* Debugging function to print out the contents of a bitmap. */
+
+void
+debug_bitmap_file (FILE *file, const_bitmap head)
+{
+ const bitmap_element *ptr;
+
+ fprintf (file, "\nfirst = %p current = %p indx = %u\n",
+ (void *) head->first, (void *) head->current, head->indx);
+
+ for (ptr = head->first; ptr; ptr = ptr->next)
+ {
+ unsigned int i, j, col = 26;
+
+ fprintf (file, "\t%p next = %p prev = %p indx = %u\n\t\tbits = {",
+ (const void*) ptr, (const void*) ptr->next,
+ (const void*) ptr->prev, ptr->indx);
+
+ for (i = 0; i < BITMAP_ELEMENT_WORDS; i++)
+ for (j = 0; j < BITMAP_WORD_BITS; j++)
+ if ((ptr->bits[i] >> j) & 1)
+ {
+ if (col > 70)
+ {
+ fprintf (file, "\n\t\t\t");
+ col = 24;
+ }
+
+ fprintf (file, " %u", (ptr->indx * BITMAP_ELEMENT_ALL_BITS
+ + i * BITMAP_WORD_BITS + j));
+ col += 4;
+ }
+
+ fprintf (file, " }\n");
+ }
+}
+
+/* Function to be called from the debugger to print the contents
+ of a bitmap. */
+
+void
+debug_bitmap (const_bitmap head)
+{
+ debug_bitmap_file (stdout, head);
+}
+
+/* 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;
- char *prefix;
- char *suffix;
+bitmap_print (FILE *file, const_bitmap head, const char *prefix, const char *suffix)
{
- char *comma = "";
- int i;
+ const char *comma = "";
+ unsigned i;
+ bitmap_iterator bi;
fputs (prefix, file);
- EXECUTE_IF_SET_IN_BITMAP (head, 0, i,
- {
- fprintf (file, "%s%d", comma, i);
- comma = ", ";
- });
+ EXECUTE_IF_SET_IN_BITMAP (head, 0, i, bi)
+ {
+ fprintf (file, "%s%d", comma, i);
+ comma = ", ";
+ }
fputs (suffix, file);
}
-\f
-/* Release any memory allocated by bitmaps. */
+#ifdef GATHER_STATISTICS
+
+/* Used to accumulate statistics about bitmap sizes. */
+struct output_info
+{
+ int count;
+ int size;
+};
+
+/* Called via htab_traverse. Output bitmap descriptor pointed out by SLOT
+ and update statistics. */
+static int
+print_statistics (void **slot, void *b)
+{
+ struct bitmap_descriptor *d = (struct bitmap_descriptor *) *slot;
+ struct output_info *i = (struct output_info *) b;
+ char s[4096];
+
+ if (d->allocated)
+ {
+ const char *s1 = d->file;
+ const char *s2;
+ while ((s2 = strstr (s1, "gcc/")))
+ s1 = s2 + 4;
+ sprintf (s, "%s:%i (%s)", s1, d->line, d->function);
+ s[41] = 0;
+ fprintf (stderr, "%-41s %6d %10d %10d %10d %10d\n", s,
+ d->created, d->allocated, d->peak, d->current, d->nsearches);
+ i->size += d->allocated;
+ i->count += d->created;
+ }
+ return 1;
+}
+#endif
+/* Output per-bitmap memory usage statistics. */
void
-bitmap_release_memory ()
+dump_bitmap_statistics (void)
{
- bitmap_free = 0;
- if (bitmap_obstack_init)
+#ifdef GATHER_STATISTICS
+ struct output_info info;
+
+ if (!bitmap_desc_hash)
+ return;
+
+ fprintf (stderr, "\nBitmap Overall "
+ "Allocated Peak Leak searched "
+ " per search\n");
+ fprintf (stderr, "---------------------------------------------------------------------------------\n");
+ info.count = 0;
+ info.size = 0;
+ htab_traverse (bitmap_desc_hash, print_statistics, &info);
+ fprintf (stderr, "---------------------------------------------------------------------------------\n");
+ fprintf (stderr, "%-40s %7d %10d\n",
+ "Total", info.count, info.size);
+ fprintf (stderr, "---------------------------------------------------------------------------------\n");
+#endif
+}
+
+/* Compute hash of bitmap (for purposes of hashing). */
+hashval_t
+bitmap_hash (const_bitmap head)
+{
+ const bitmap_element *ptr;
+ BITMAP_WORD hash = 0;
+ int ix;
+
+ for (ptr = head->first; ptr; ptr = ptr->next)
{
- bitmap_obstack_init = FALSE;
- obstack_free (&bitmap_obstack, NULL_PTR);
+ hash ^= ptr->indx;
+ for (ix = 0; ix != BITMAP_ELEMENT_WORDS; ix++)
+ hash ^= ptr->bits[ix];
}
+ return (hashval_t)hash;
}
+
+#include "gt-bitmap.h"