gcc/bitmap.h

   1 /* Functions to support general ended bitmaps.
   2    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 3, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING3.  If not see
  19 <http://www.gnu.org/licenses/>.  */
  20
  21 #ifndef GCC_BITMAP_H
  22 #define GCC_BITMAP_H
  23 #include "hashtab.h"
  24 #include "statistics.h"
  25 #include "obstack.h"
  26
  27 /* Fundamental storage type for bitmap.  */
  28
  29 typedef unsigned long BITMAP_WORD;
  30 /* BITMAP_WORD_BITS needs to be unsigned, but cannot contain casts as
  31    it is used in preprocessor directives -- hence the 1u.  */
  32 #define BITMAP_WORD_BITS (CHAR_BIT * SIZEOF_LONG * 1u)
  33
  34 /* Number of words to use for each element in the linked list.  */
  35
  36 #ifndef BITMAP_ELEMENT_WORDS
  37 #define BITMAP_ELEMENT_WORDS ((128 + BITMAP_WORD_BITS - 1) / BITMAP_WORD_BITS)
  38 #endif
  39
  40 /* Number of bits in each actual element of a bitmap.  */
  41
  42 #define BITMAP_ELEMENT_ALL_BITS (BITMAP_ELEMENT_WORDS * BITMAP_WORD_BITS)
  43
  44 /* Obstack for allocating bitmaps and elements from.  */
  45 typedef struct GTY (()) bitmap_obstack {
  46   struct bitmap_element_def *elements;
  47   struct bitmap_head_def *heads;
  48   struct obstack GTY ((skip)) obstack;
  49 } bitmap_obstack;
  50
  51 /* Bitmap set element.  We use a linked list to hold only the bits that
  52    are set.  This allows for use to grow the bitset dynamically without
  53    having to realloc and copy a giant bit array.
  54
  55    The free list is implemented as a list of lists.  There is one
  56    outer list connected together by prev fields.  Each element of that
  57    outer is an inner list (that may consist only of the outer list
  58    element) that are connected by the next fields.  The prev pointer
  59    is undefined for interior elements.  This allows
  60    bitmap_elt_clear_from to be implemented in unit time rather than
  61    linear in the number of elements to be freed.  */
  62
  63 typedef struct GTY(()) bitmap_element_def {
  64   struct bitmap_element_def *next;              /* Next element.  */
  65   struct bitmap_element_def *prev;              /* Previous element.  */
  66   unsigned int indx;                    /* regno/BITMAP_ELEMENT_ALL_BITS.  */
  67   BITMAP_WORD bits[BITMAP_ELEMENT_WORDS]; /* Bits that are set.  */
  68 } bitmap_element;
  69
  70 struct bitmap_descriptor;
  71 /* Head of bitmap linked list.  gengtype ignores ifdefs, but for
  72    statistics we need to add a bitmap descriptor pointer.  As it is
  73    not collected, we can just GTY((skip)) it.   */
  74
  75 typedef struct GTY(()) bitmap_head_def {
  76   bitmap_element *first;        /* First element in linked list.  */
  77   bitmap_element *current;      /* Last element looked at.  */
  78   unsigned int indx;            /* Index of last element looked at.  */
  79   bitmap_obstack *obstack;      /* Obstack to allocate elements from.
  80                                    If NULL, then use GGC allocation.  */
  81 #ifdef GATHER_STATISTICS
  82   struct bitmap_descriptor GTY((skip)) *desc;
  83 #endif
  84 } bitmap_head;
  85
  86 /* Global data */
  87 extern bitmap_element bitmap_zero_bits; /* Zero bitmap element */
  88 extern bitmap_obstack bitmap_default_obstack;   /* Default bitmap obstack */
  89
  90 /* Clear a bitmap by freeing up the linked list.  */
  91 extern void bitmap_clear (bitmap);
  92
  93 /* Copy a bitmap to another bitmap.  */
  94 extern void bitmap_copy (bitmap, const_bitmap);
  95
  96 /* True if two bitmaps are identical.  */
  97 extern bool bitmap_equal_p (const_bitmap, const_bitmap);
  98
  99 /* True if the bitmaps intersect (their AND is non-empty).  */
 100 extern bool bitmap_intersect_p (const_bitmap, const_bitmap);
 101
 102 /* True if the complement of the second intersects the first (their
 103    AND_COMPL is non-empty).  */
 104 extern bool bitmap_intersect_compl_p (const_bitmap, const_bitmap);
 105
 106 /* True if MAP is an empty bitmap.  */
 107 #define bitmap_empty_p(MAP) (!(MAP)->first)
 108
 109 /* True if the bitmap has only a single bit set.  */
 110 extern bool bitmap_single_bit_set_p (const_bitmap);
 111
 112 /* Count the number of bits set in the bitmap.  */
 113 extern unsigned long bitmap_count_bits (const_bitmap);
 114
 115 /* Boolean operations on bitmaps.  The _into variants are two operand
 116    versions that modify the first source operand.  The other variants
 117    are three operand versions that to not destroy the source bitmaps.
 118    The operations supported are &, & ~, |, ^.  */
 119 extern void bitmap_and (bitmap, const_bitmap, const_bitmap);
 120 extern void bitmap_and_into (bitmap, const_bitmap);
 121 extern bool bitmap_and_compl (bitmap, const_bitmap, const_bitmap);
 122 extern bool bitmap_and_compl_into (bitmap, const_bitmap);
 123 #define bitmap_compl_and(DST, A, B) bitmap_and_compl (DST, B, A)
 124 extern void bitmap_compl_and_into (bitmap, const_bitmap);
 125 extern void bitmap_clear_range (bitmap, unsigned int, unsigned int);
 126 extern void bitmap_set_range (bitmap, unsigned int, unsigned int);
 127 extern bool bitmap_ior (bitmap, const_bitmap, const_bitmap);
 128 extern bool bitmap_ior_into (bitmap, const_bitmap);
 129 extern void bitmap_xor (bitmap, const_bitmap, const_bitmap);
 130 extern void bitmap_xor_into (bitmap, const_bitmap);
 131
 132 /* DST = A | (B & C).  Return true if DST changes.  */
 133 extern bool bitmap_ior_and_into (bitmap DST, const_bitmap B, const_bitmap C);
 134 /* DST = A | (B & ~C).  Return true if DST changes.  */
 135 extern bool bitmap_ior_and_compl (bitmap DST, const_bitmap A, const_bitmap B, const_bitmap C);
 136 /* A |= (B & ~C).  Return true if A changes.  */
 137 extern bool bitmap_ior_and_compl_into (bitmap DST, const_bitmap B, const_bitmap C);
 138
 139 /* Clear a single bit in a bitmap.  Return true if the bit changed.  */
 140 extern bool bitmap_clear_bit (bitmap, int);
 141
 142 /* Set a single bit in a bitmap.  Return true if the bit changed.  */
 143 extern bool bitmap_set_bit (bitmap, int);
 144
 145 /* Return true if a register is set in a register set.  */
 146 extern int bitmap_bit_p (bitmap, int);
 147
 148 /* Debug functions to print a bitmap linked list.  */
 149 extern void debug_bitmap (const_bitmap);
 150 extern void debug_bitmap_file (FILE *, const_bitmap);
 151
 152 /* Print a bitmap.  */
 153 extern void bitmap_print (FILE *, const_bitmap, const char *, const char *);
 154
 155 /* Initialize and release a bitmap obstack.  */
 156 extern void bitmap_obstack_initialize (bitmap_obstack *);
 157 extern void bitmap_obstack_release (bitmap_obstack *);
 158 extern void bitmap_register (bitmap MEM_STAT_DECL);
 159 extern void dump_bitmap_statistics (void);
 160
 161 /* Initialize a bitmap header.  OBSTACK indicates the bitmap obstack
 162    to allocate from, NULL for GC'd bitmap.  */
 163
 164 static inline void
 165 bitmap_initialize_stat (bitmap head, bitmap_obstack *obstack MEM_STAT_DECL)
 166 {
 167   head->first = head->current = NULL;
 168   head->obstack = obstack;
 169 #ifdef GATHER_STATISTICS
 170   bitmap_register (head PASS_MEM_STAT);
 171 #endif
 172 }
 173 #define bitmap_initialize(h,o) bitmap_initialize_stat (h,o MEM_STAT_INFO)
 174
 175 /* Allocate and free bitmaps from obstack, malloc and gc'd memory.  */
 176 extern bitmap bitmap_obstack_alloc_stat (bitmap_obstack *obstack MEM_STAT_DECL);
 177 #define bitmap_obstack_alloc(t) bitmap_obstack_alloc_stat (t MEM_STAT_INFO)
 178 extern bitmap bitmap_gc_alloc_stat (ALONE_MEM_STAT_DECL);
 179 #define bitmap_gc_alloc() bitmap_gc_alloc_stat (ALONE_MEM_STAT_INFO)
 180 extern void bitmap_obstack_free (bitmap);
 181
 182 /* A few compatibility/functions macros for compatibility with sbitmaps */
 183 #define dump_bitmap(file, bitmap) bitmap_print (file, bitmap, "", "\n")
 184 #define bitmap_zero(a) bitmap_clear (a)
 185 extern unsigned bitmap_first_set_bit (const_bitmap);
 186 extern unsigned bitmap_last_set_bit (const_bitmap);
 187
 188 /* Compute bitmap hash (for purposes of hashing etc.)  */
 189 extern hashval_t bitmap_hash(const_bitmap);
 190
 191 /* Allocate a bitmap from a bit obstack.  */
 192 #define BITMAP_ALLOC(OBSTACK) bitmap_obstack_alloc (OBSTACK)
 193
 194 /* Allocate a gc'd bitmap.  */
 195 #define BITMAP_GGC_ALLOC() bitmap_gc_alloc ()
 196
 197 /* Do any cleanup needed on a bitmap when it is no longer used.  */
 198 #define BITMAP_FREE(BITMAP) \
 199        ((void) (bitmap_obstack_free ((bitmap) BITMAP), (BITMAP) = (bitmap) NULL))
 200
 201 /* Iterator for bitmaps.  */
 202
 203 typedef struct
 204 {
 205   /* Pointer to the current bitmap element.  */
 206   bitmap_element *elt1;
 207
 208   /* Pointer to 2nd bitmap element when two are involved.  */
 209   bitmap_element *elt2;
 210
 211   /* Word within the current element.  */
 212   unsigned word_no;
 213
 214   /* Contents of the actually processed word.  When finding next bit
 215      it is shifted right, so that the actual bit is always the least
 216      significant bit of ACTUAL.  */
 217   BITMAP_WORD bits;
 218 } bitmap_iterator;
 219
 220 /* Initialize a single bitmap iterator.  START_BIT is the first bit to
 221    iterate from.  */
 222
 223 static inline void
 224 bmp_iter_set_init (bitmap_iterator *bi, const_bitmap map,
 225                    unsigned start_bit, unsigned *bit_no)
 226 {
 227   bi->elt1 = map->first;
 228   bi->elt2 = NULL;
 229
 230   /* Advance elt1 until it is not before the block containing start_bit.  */
 231   while (1)
 232     {
 233       if (!bi->elt1)
 234         {
 235           bi->elt1 = &bitmap_zero_bits;
 236           break;
 237         }
 238
 239       if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
 240         break;
 241       bi->elt1 = bi->elt1->next;
 242     }
 243
 244   /* We might have gone past the start bit, so reinitialize it.  */
 245   if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
 246     start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 247
 248   /* Initialize for what is now start_bit.  */
 249   bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
 250   bi->bits = bi->elt1->bits[bi->word_no];
 251   bi->bits >>= start_bit % BITMAP_WORD_BITS;
 252
 253   /* If this word is zero, we must make sure we're not pointing at the
 254      first bit, otherwise our incrementing to the next word boundary
 255      will fail.  It won't matter if this increment moves us into the
 256      next word.  */
 257   start_bit += !bi->bits;
 258
 259   *bit_no = start_bit;
 260 }
 261
 262 /* Initialize an iterator to iterate over the intersection of two
 263    bitmaps.  START_BIT is the bit to commence from.  */
 264
 265 static inline void
 266 bmp_iter_and_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2,
 267                    unsigned start_bit, unsigned *bit_no)
 268 {
 269   bi->elt1 = map1->first;
 270   bi->elt2 = map2->first;
 271
 272   /* Advance elt1 until it is not before the block containing
 273      start_bit.  */
 274   while (1)
 275     {
 276       if (!bi->elt1)
 277         {
 278           bi->elt2 = NULL;
 279           break;
 280         }
 281
 282       if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
 283         break;
 284       bi->elt1 = bi->elt1->next;
 285     }
 286
 287   /* Advance elt2 until it is not before elt1.  */
 288   while (1)
 289     {
 290       if (!bi->elt2)
 291         {
 292           bi->elt1 = bi->elt2 = &bitmap_zero_bits;
 293           break;
 294         }
 295
 296       if (bi->elt2->indx >= bi->elt1->indx)
 297         break;
 298       bi->elt2 = bi->elt2->next;
 299     }
 300
 301   /* If we're at the same index, then we have some intersecting bits.  */
 302   if (bi->elt1->indx == bi->elt2->indx)
 303     {
 304       /* We might have advanced beyond the start_bit, so reinitialize
 305          for that.  */
 306       if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
 307         start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 308
 309       bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
 310       bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
 311       bi->bits >>= start_bit % BITMAP_WORD_BITS;
 312     }
 313   else
 314     {
 315       /* Otherwise we must immediately advance elt1, so initialize for
 316          that.  */
 317       bi->word_no = BITMAP_ELEMENT_WORDS - 1;
 318       bi->bits = 0;
 319     }
 320
 321   /* If this word is zero, we must make sure we're not pointing at the
 322      first bit, otherwise our incrementing to the next word boundary
 323      will fail.  It won't matter if this increment moves us into the
 324      next word.  */
 325   start_bit += !bi->bits;
 326
 327   *bit_no = start_bit;
 328 }
 329
 330 /* Initialize an iterator to iterate over the bits in MAP1 & ~MAP2.
 331    */
 332
 333 static inline void
 334 bmp_iter_and_compl_init (bitmap_iterator *bi, const_bitmap map1, const_bitmap map2,
 335                          unsigned start_bit, unsigned *bit_no)
 336 {
 337   bi->elt1 = map1->first;
 338   bi->elt2 = map2->first;
 339
 340   /* Advance elt1 until it is not before the block containing start_bit.  */
 341   while (1)
 342     {
 343       if (!bi->elt1)
 344         {
 345           bi->elt1 = &bitmap_zero_bits;
 346           break;
 347         }
 348
 349       if (bi->elt1->indx >= start_bit / BITMAP_ELEMENT_ALL_BITS)
 350         break;
 351       bi->elt1 = bi->elt1->next;
 352     }
 353
 354   /* Advance elt2 until it is not before elt1.  */
 355   while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
 356     bi->elt2 = bi->elt2->next;
 357
 358   /* We might have advanced beyond the start_bit, so reinitialize for
 359      that.  */
 360   if (bi->elt1->indx != start_bit / BITMAP_ELEMENT_ALL_BITS)
 361     start_bit = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 362
 363   bi->word_no = start_bit / BITMAP_WORD_BITS % BITMAP_ELEMENT_WORDS;
 364   bi->bits = bi->elt1->bits[bi->word_no];
 365   if (bi->elt2 && bi->elt1->indx == bi->elt2->indx)
 366     bi->bits &= ~bi->elt2->bits[bi->word_no];
 367   bi->bits >>= start_bit % BITMAP_WORD_BITS;
 368
 369   /* If this word is zero, we must make sure we're not pointing at the
 370      first bit, otherwise our incrementing to the next word boundary
 371      will fail.  It won't matter if this increment moves us into the
 372      next word.  */
 373   start_bit += !bi->bits;
 374
 375   *bit_no = start_bit;
 376 }
 377
 378 /* Advance to the next bit in BI.  We don't advance to the next
 379    nonzero bit yet.  */
 380
 381 static inline void
 382 bmp_iter_next (bitmap_iterator *bi, unsigned *bit_no)
 383 {
 384   bi->bits >>= 1;
 385   *bit_no += 1;
 386 }
 387
 388 /* Advance to first set bit in BI.  */
 389
 390 static inline void
 391 bmp_iter_next_bit (bitmap_iterator * bi, unsigned *bit_no)
 392 {
 393 #if (GCC_VERSION >= 3004)
 394   {
 395     unsigned int n = __builtin_ctzl (bi->bits);
 396     gcc_assert (sizeof (unsigned long) == sizeof (BITMAP_WORD));
 397     bi->bits >>= n;
 398     *bit_no += n;
 399   }
 400 #else
 401   while (!(bi->bits & 1))
 402     {
 403       bi->bits >>= 1;
 404       *bit_no += 1;
 405     }
 406 #endif
 407 }
 408
 409 /* Advance to the next nonzero bit of a single bitmap, we will have
 410    already advanced past the just iterated bit.  Return true if there
 411    is a bit to iterate.  */
 412
 413 static inline bool
 414 bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
 415 {
 416   /* If our current word is nonzero, it contains the bit we want.  */
 417   if (bi->bits)
 418     {
 419     next_bit:
 420       bmp_iter_next_bit (bi, bit_no);
 421       return true;
 422     }
 423
 424   /* Round up to the word boundary.  We might have just iterated past
 425      the end of the last word, hence the -1.  It is not possible for
 426      bit_no to point at the beginning of the now last word.  */
 427   *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
 428              / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
 429   bi->word_no++;
 430
 431   while (1)
 432     {
 433       /* Find the next nonzero word in this elt.  */
 434       while (bi->word_no != BITMAP_ELEMENT_WORDS)
 435         {
 436           bi->bits = bi->elt1->bits[bi->word_no];
 437           if (bi->bits)
 438             goto next_bit;
 439           *bit_no += BITMAP_WORD_BITS;
 440           bi->word_no++;
 441         }
 442
 443       /* Advance to the next element.  */
 444       bi->elt1 = bi->elt1->next;
 445       if (!bi->elt1)
 446         return false;
 447       *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 448       bi->word_no = 0;
 449     }
 450 }
 451
 452 /* Advance to the next nonzero bit of an intersecting pair of
 453    bitmaps.  We will have already advanced past the just iterated bit.
 454    Return true if there is a bit to iterate.  */
 455
 456 static inline bool
 457 bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no)
 458 {
 459   /* If our current word is nonzero, it contains the bit we want.  */
 460   if (bi->bits)
 461     {
 462     next_bit:
 463       bmp_iter_next_bit (bi, bit_no);
 464       return true;
 465     }
 466
 467   /* Round up to the word boundary.  We might have just iterated past
 468      the end of the last word, hence the -1.  It is not possible for
 469      bit_no to point at the beginning of the now last word.  */
 470   *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
 471              / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
 472   bi->word_no++;
 473
 474   while (1)
 475     {
 476       /* Find the next nonzero word in this elt.  */
 477       while (bi->word_no != BITMAP_ELEMENT_WORDS)
 478         {
 479           bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
 480           if (bi->bits)
 481             goto next_bit;
 482           *bit_no += BITMAP_WORD_BITS;
 483           bi->word_no++;
 484         }
 485
 486       /* Advance to the next identical element.  */
 487       do
 488         {
 489           /* Advance elt1 while it is less than elt2.  We always want
 490              to advance one elt.  */
 491           do
 492             {
 493               bi->elt1 = bi->elt1->next;
 494               if (!bi->elt1)
 495                 return false;
 496             }
 497           while (bi->elt1->indx < bi->elt2->indx);
 498
 499           /* Advance elt2 to be no less than elt1.  This might not
 500              advance.  */
 501           while (bi->elt2->indx < bi->elt1->indx)
 502             {
 503               bi->elt2 = bi->elt2->next;
 504               if (!bi->elt2)
 505                 return false;
 506             }
 507         }
 508       while (bi->elt1->indx != bi->elt2->indx);
 509
 510       *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 511       bi->word_no = 0;
 512     }
 513 }
 514
 515 /* Advance to the next nonzero bit in the intersection of
 516    complemented bitmaps.  We will have already advanced past the just
 517    iterated bit.  */
 518
 519 static inline bool
 520 bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
 521 {
 522   /* If our current word is nonzero, it contains the bit we want.  */
 523   if (bi->bits)
 524     {
 525     next_bit:
 526       bmp_iter_next_bit (bi, bit_no);
 527       return true;
 528     }
 529
 530   /* Round up to the word boundary.  We might have just iterated past
 531      the end of the last word, hence the -1.  It is not possible for
 532      bit_no to point at the beginning of the now last word.  */
 533   *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
 534              / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
 535   bi->word_no++;
 536
 537   while (1)
 538     {
 539       /* Find the next nonzero word in this elt.  */
 540       while (bi->word_no != BITMAP_ELEMENT_WORDS)
 541         {
 542           bi->bits = bi->elt1->bits[bi->word_no];
 543           if (bi->elt2 && bi->elt2->indx == bi->elt1->indx)
 544             bi->bits &= ~bi->elt2->bits[bi->word_no];
 545           if (bi->bits)
 546             goto next_bit;
 547           *bit_no += BITMAP_WORD_BITS;
 548           bi->word_no++;
 549         }
 550
 551       /* Advance to the next element of elt1.  */
 552       bi->elt1 = bi->elt1->next;
 553       if (!bi->elt1)
 554         return false;
 555
 556       /* Advance elt2 until it is no less than elt1.  */
 557       while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
 558         bi->elt2 = bi->elt2->next;
 559
 560       *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
 561       bi->word_no = 0;
 562     }
 563 }
 564
 565 /* Loop over all bits set in BITMAP, starting with MIN and setting
 566    BITNUM to the bit number.  ITER is a bitmap iterator.  BITNUM
 567    should be treated as a read-only variable as it contains loop
 568    state.  */
 569
 570 #define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, ITER)             \
 571   for (bmp_iter_set_init (&(ITER), (BITMAP), (MIN), &(BITNUM));         \
 572        bmp_iter_set (&(ITER), &(BITNUM));                               \
 573        bmp_iter_next (&(ITER), &(BITNUM)))
 574
 575 /* Loop over all the bits set in BITMAP1 & BITMAP2, starting with MIN
 576    and setting BITNUM to the bit number.  ITER is a bitmap iterator.
 577    BITNUM should be treated as a read-only variable as it contains
 578    loop state.  */
 579
 580 #define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER)   \
 581   for (bmp_iter_and_init (&(ITER), (BITMAP1), (BITMAP2), (MIN),         \
 582                           &(BITNUM));                                   \
 583        bmp_iter_and (&(ITER), &(BITNUM));                               \
 584        bmp_iter_next (&(ITER), &(BITNUM)))
 585
 586 /* Loop over all the bits set in BITMAP1 & ~BITMAP2, starting with MIN
 587    and setting BITNUM to the bit number.  ITER is a bitmap iterator.
 588    BITNUM should be treated as a read-only variable as it contains
 589    loop state.  */
 590
 591 #define EXECUTE_IF_AND_COMPL_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \
 592   for (bmp_iter_and_compl_init (&(ITER), (BITMAP1), (BITMAP2), (MIN),   \
 593                                 &(BITNUM));                             \
 594        bmp_iter_and_compl (&(ITER), &(BITNUM));                         \
 595        bmp_iter_next (&(ITER), &(BITNUM)))
 596
 597 #endif /* GCC_BITMAP_H */