* 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.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@61793 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d867e8c..efffdb4 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -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>

diff --git a/gcc/bitmap.c b/gcc/bitmap.c
index 7b93eab..4575f62 100644 (file)
--- a/gcc/bitmap.c
+++ b/gcc/bitmap.c
@@ -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);
 }
 \f
@@ -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;
            }
 

diff --git a/gcc/bitmap.h b/gcc/bitmap.h
index ed40299..85f8239 100644 (file)
--- a/gcc/bitmap.h
+++ b/gcc/bitmap.h
@@ -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;                                             \