OpenE2K
/
gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bitmap.h (BITMAP_WORD): New typedef: fundamental storage type for bitmaps. 

* bitmap.h (BITMAP_WORD): New typedef: fundamental storage
        type for bitmaps.  Use unsigned long.
        (nBITMAP_WORD_BITS): New macro.
        (BITMAP_WORD_BITS): New macro.
        (rest of file): Use it.
        * bitmap.c: Use it.

From-SVN: r61793
This commit is contained in:
Segher Boessenkool 2003-01-25 19:21:22 +01:00 committed by Richard Henderson
parent bbaab9162a
commit 72e42e26cb
3 changed files with 66 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
gcc/ChangeLog
View File

@ -1,3 +1,12 @@
2003-01-25 Segher Boessenkool <segher@koffie.nl>
* bitmap.h (BITMAP_WORD): New typedef: fundamental storage
type for bitmaps. Use unsigned long.
(nBITMAP_WORD_BITS): New macro.
(BITMAP_WORD_BITS): New macro.
(rest of file): Use it.
* bitmap.c: Use it.
2003-01-25 Richard Henderson <rth@redhat.com>
2002-02-19 Robert Lipe <robertlipe@usa.net>

52
gcc/bitmap.c
View File

@ -1,5 +1,6 @@
/* Functions to support general ended bitmaps.
Copyright (C) 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2003
Free Software Foundation, Inc.
This file is part of GCC.
@ -332,7 +333,7 @@ bitmap_find_bit (head, bit)
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
|| head->indx == indx)
@ -371,10 +372,9 @@ bitmap_clear_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 (bitmap_element_zerop (ptr))
@ -390,10 +390,9 @@ bitmap_set_bit (head, bit)
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)
{
@ -421,9 +420,8 @@ bitmap_bit_p (head, bit)
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;
}
@ -436,7 +434,7 @@ bitmap_first_set_bit (a)
bitmap a;
{
bitmap_element *ptr = a->first;
unsigned HOST_WIDE_INT word;
BITMAP_WORD word;
unsigned word_num, bit_num;
if (ptr == NULL)
@ -458,10 +456,10 @@ bitmap_first_set_bit (a)
bit_num = 0;
word = word & -word;
#if HOST_BITS_PER_WIDE_INT > 64
#if nBITMAP_WORD_BITS > 64
#error "Fill out the table."
#endif
#if HOST_BITS_PER_WIDE_INT > 32
#if nBITMAP_WORD_BITS > 32
if ((word & 0xffffffff) == 0)
word >>= 32, bit_num += 32;
#endif
@ -477,7 +475,7 @@ bitmap_first_set_bit (a)
bit_num += 1;
return (ptr->indx * BITMAP_ELEMENT_ALL_BITS
+ word_num * HOST_BITS_PER_WIDE_INT
+ word_num * BITMAP_WORD_BITS
+ bit_num);
}
@ -489,7 +487,7 @@ bitmap_last_set_bit (a)
bitmap a;
{
bitmap_element *ptr = a->first;
unsigned HOST_WIDE_INT word;
BITMAP_WORD word;
unsigned word_num, bit_num;
if (ptr == NULL)
@ -511,11 +509,11 @@ bitmap_last_set_bit (a)
/* Binary search for the last set bit. */
bit_num = 0;
#if HOST_BITS_PER_WIDE_INT > 64
#if nBITMAP_WORD_BITS > 64
#error "Fill out the table."
#endif
#if HOST_BITS_PER_WIDE_INT > 32
if (word & ~ (unsigned HOST_WIDE_INT) 0xffffffff)
#if nBITMAP_WORD_BITS > 32
if (word & ~(BITMAP_WORD)0xffffffff)
word >>= 32, bit_num += 32;
#endif
if (word & 0xffff0000)
@ -530,7 +528,7 @@ bitmap_last_set_bit (a)
bit_num += 1;
return (ptr->indx * BITMAP_ELEMENT_ALL_BITS
+ word_num * HOST_BITS_PER_WIDE_INT
+ word_num * BITMAP_WORD_BITS
+ bit_num);
}
@ -560,7 +558,7 @@ bitmap_operation (to, from1, from2, operation)
#if BITMAP_ELEMENT_WORDS == 2
#define DOIT(OP) \
do { \
unsigned HOST_WIDE_INT t0, t1, f10, f11, f20, f21; \
BITMAP_WORD t0, t1, f10, f11, f20, f21; \
f10 = from1_tmp->bits[0]; \
f20 = from2_tmp->bits[0]; \
t0 = f10 OP f20; \
@ -575,7 +573,7 @@ bitmap_operation (to, from1, from2, operation)
#else
#define DOIT(OP) \
do { \
unsigned HOST_WIDE_INT t, f1, f2; \
BITMAP_WORD t, f1, f2; \
int i; \
for (i = 0; i < BITMAP_ELEMENT_WORDS; ++i) \
{ \
@ -787,7 +785,7 @@ debug_bitmap_file (file, head)
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) ptr);
@ -798,7 +796,7 @@ debug_bitmap_file (file, head)
fprintf (file, " indx = %u\n\t\tbits = {", 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)
@ -808,7 +806,7 @@ debug_bitmap_file (file, head)
}
fprintf (file, " %u", (ptr->indx * BITMAP_ELEMENT_ALL_BITS
+ i * HOST_BITS_PER_WIDE_INT + j));
+ i * BITMAP_WORD_BITS + j));
col += 4;
}

62
gcc/bitmap.h
View File

@ -1,5 +1,5 @@
/* Functions to support general ended bitmaps.
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002
Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003
Free Software Foundation, Inc.
This file is part of GCC.
@ -22,10 +22,18 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
#ifndef GCC_BITMAP_H
#define GCC_BITMAP_H
/* Fundamental storage type for bitmap. */
/* typedef unsigned HOST_WIDE_INT BITMAP_WORD; */
/* #define nBITMAP_WORD_BITS HOST_BITS_PER_WIDE_INT */
typedef unsigned long BITMAP_WORD;
#define nBITMAP_WORD_BITS (CHAR_BIT * SIZEOF_LONG)
#define BITMAP_WORD_BITS (unsigned) nBITMAP_WORD_BITS
/* Number of words to use for each element in the linked list. */
#ifndef BITMAP_ELEMENT_WORDS
#define BITMAP_ELEMENT_WORDS 2
#define BITMAP_ELEMENT_WORDS ((128 + nBITMAP_WORD_BITS - 1) / nBITMAP_WORD_BITS)
#endif
/* Number of bits in each actual element of a bitmap. We get slightly better
@ -33,7 +41,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
bits is unsigned, assuming it is a power of 2. */
#define BITMAP_ELEMENT_ALL_BITS \
((unsigned) (BITMAP_ELEMENT_WORDS * HOST_BITS_PER_WIDE_INT))
((unsigned) (BITMAP_ELEMENT_WORDS * BITMAP_WORD_BITS))
/* Bitmap set element. We use a linked list to hold only the bits that
are set. This allows for use to grow the bitset dynamically without
@ -45,7 +53,7 @@ typedef struct bitmap_element_def GTY(())
struct bitmap_element_def *next; /* Next element. */
struct bitmap_element_def *prev; /* Previous element. */
unsigned int indx; /* regno/BITMAP_ELEMENT_ALL_BITS. */
unsigned HOST_WIDE_INT bits[BITMAP_ELEMENT_WORDS]; /* Bits that are set. */
BITMAP_WORD bits[BITMAP_ELEMENT_WORDS]; /* Bits that are set. */
} bitmap_element;
/* Head of bitmap linked list. */
@ -162,9 +170,8 @@ do { \
do { \
bitmap_element *ptr_ = (BITMAP)->first; \
unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
% BITMAP_ELEMENT_WORDS); \
unsigned bit_num_ = (MIN) % BITMAP_WORD_BITS; \
unsigned word_num_ = (MIN) / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; \
\
\
/* Find the block the minimum bit is in. */ \
@ -181,20 +188,19 @@ do { \
{ \
for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
{ \
unsigned HOST_WIDE_INT word_ = ptr_->bits[word_num_]; \
BITMAP_WORD word_ = ptr_->bits[word_num_]; \
\
if (word_ != 0) \
{ \
for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
for (; bit_num_ < BITMAP_WORD_BITS; bit_num_++) \
{ \
unsigned HOST_WIDE_INT mask_ \
= ((unsigned HOST_WIDE_INT) 1) << bit_num_; \
BITMAP_WORD mask_ = ((BITMAP_WORD) 1) << bit_num_; \
\
if ((word_ & mask_) != 0) \
{ \
word_ &= ~ mask_; \
(BITNUM) = (ptr_->indx * BITMAP_ELEMENT_ALL_BITS \
+ word_num_ * HOST_BITS_PER_WIDE_INT \
+ word_num_ * BITMAP_WORD_BITS \
+ bit_num_); \
CODE; \
\
@ -220,9 +226,8 @@ do { \
bitmap_element *ptr1_ = (BITMAP1)->first; \
bitmap_element *ptr2_ = (BITMAP2)->first; \
unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
% BITMAP_ELEMENT_WORDS); \
unsigned bit_num_ = (MIN) % BITMAP_WORD_BITS; \
unsigned word_num_ = (MIN) / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; \
\
/* Find the block the minimum bit is in in the first bitmap. */ \
while (ptr1_ != 0 && ptr1_->indx < indx_) \
@ -248,20 +253,19 @@ do { \
\
for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
{ \
unsigned HOST_WIDE_INT word_ = (ptr1_->bits[word_num_] \
& ~ tmp2_->bits[word_num_]); \
BITMAP_WORD word_ = (ptr1_->bits[word_num_] \
& ~ tmp2_->bits[word_num_]); \
if (word_ != 0) \
{ \
for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
for (; bit_num_ < BITMAP_WORD_BITS; bit_num_++) \
{ \
unsigned HOST_WIDE_INT mask_ \
= ((unsigned HOST_WIDE_INT)1) << bit_num_; \
BITMAP_WORD mask_ = ((BITMAP_WORD) 1) << bit_num_; \
\
if ((word_ & mask_) != 0) \
{ \
word_ &= ~ mask_; \
(BITNUM) = (ptr1_->indx * BITMAP_ELEMENT_ALL_BITS \
+ word_num_ * HOST_BITS_PER_WIDE_INT \
+ word_num_ * BITMAP_WORD_BITS \
+ bit_num_); \
\
CODE; \
@ -287,9 +291,8 @@ do { \
bitmap_element *ptr1_ = (BITMAP1)->first; \
bitmap_element *ptr2_ = (BITMAP2)->first; \
unsigned int indx_ = (MIN) / BITMAP_ELEMENT_ALL_BITS; \
unsigned bit_num_ = (MIN) % ((unsigned) HOST_BITS_PER_WIDE_INT); \
unsigned word_num_ = (((MIN) / ((unsigned) HOST_BITS_PER_WIDE_INT)) \
% BITMAP_ELEMENT_WORDS); \
unsigned bit_num_ = (MIN) % BITMAP_WORD_BITS; \
unsigned word_num_ = (MIN) / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS; \
\
/* Find the block the minimum bit is in in the first bitmap. */ \
while (ptr1_ != 0 && ptr1_->indx < indx_) \
@ -321,20 +324,19 @@ do { \
\
for (; word_num_ < BITMAP_ELEMENT_WORDS; word_num_++) \
{ \
unsigned HOST_WIDE_INT word_ = (ptr1_->bits[word_num_] \
& ptr2_->bits[word_num_]); \
BITMAP_WORD word_ = (ptr1_->bits[word_num_] \
& ptr2_->bits[word_num_]); \
if (word_ != 0) \
{ \
for (; bit_num_ < HOST_BITS_PER_WIDE_INT; bit_num_++) \
for (; bit_num_ < BITMAP_WORD_BITS; bit_num_++) \
{ \
unsigned HOST_WIDE_INT mask_ \
= ((unsigned HOST_WIDE_INT)1) << bit_num_; \
BITMAP_WORD mask_ = ((BITMAP_WORD) 1) << bit_num_; \
\
if ((word_ & mask_) != 0) \
{ \
word_ &= ~ mask_; \
(BITNUM) = (ptr1_->indx * BITMAP_ELEMENT_ALL_BITS \
+ word_num_ * HOST_BITS_PER_WIDE_INT \
+ word_num_ * BITMAP_WORD_BITS \
+ bit_num_); \
\
CODE; \