OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [gcc-4.5.1/] [gcc/] [bitmap.h] - Blame information for rev 826

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Functions to support general ended bitmaps.
2
   Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3
   2006, 2007, 2008, 2009 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_alloc.  */
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 the next nonzero bit of a single bitmap, we will have
389
   already advanced past the just iterated bit.  Return true if there
390
   is a bit to iterate.  */
391
 
392
static inline bool
393
bmp_iter_set (bitmap_iterator *bi, unsigned *bit_no)
394
{
395
  /* If our current word is nonzero, it contains the bit we want.  */
396
  if (bi->bits)
397
    {
398
    next_bit:
399
      while (!(bi->bits & 1))
400
        {
401
          bi->bits >>= 1;
402
          *bit_no += 1;
403
        }
404
      return true;
405
    }
406
 
407
  /* Round up to the word boundary.  We might have just iterated past
408
     the end of the last word, hence the -1.  It is not possible for
409
     bit_no to point at the beginning of the now last word.  */
410
  *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
411
             / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
412
  bi->word_no++;
413
 
414
  while (1)
415
    {
416
      /* Find the next nonzero word in this elt.  */
417
      while (bi->word_no != BITMAP_ELEMENT_WORDS)
418
        {
419
          bi->bits = bi->elt1->bits[bi->word_no];
420
          if (bi->bits)
421
            goto next_bit;
422
          *bit_no += BITMAP_WORD_BITS;
423
          bi->word_no++;
424
        }
425
 
426
      /* Advance to the next element.  */
427
      bi->elt1 = bi->elt1->next;
428
      if (!bi->elt1)
429
        return false;
430
      *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
431
      bi->word_no = 0;
432
    }
433
}
434
 
435
/* Advance to the next nonzero bit of an intersecting pair of
436
   bitmaps.  We will have already advanced past the just iterated bit.
437
   Return true if there is a bit to iterate.  */
438
 
439
static inline bool
440
bmp_iter_and (bitmap_iterator *bi, unsigned *bit_no)
441
{
442
  /* If our current word is nonzero, it contains the bit we want.  */
443
  if (bi->bits)
444
    {
445
    next_bit:
446
      while (!(bi->bits & 1))
447
        {
448
          bi->bits >>= 1;
449
          *bit_no += 1;
450
        }
451
      return true;
452
    }
453
 
454
  /* Round up to the word boundary.  We might have just iterated past
455
     the end of the last word, hence the -1.  It is not possible for
456
     bit_no to point at the beginning of the now last word.  */
457
  *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
458
             / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
459
  bi->word_no++;
460
 
461
  while (1)
462
    {
463
      /* Find the next nonzero word in this elt.  */
464
      while (bi->word_no != BITMAP_ELEMENT_WORDS)
465
        {
466
          bi->bits = bi->elt1->bits[bi->word_no] & bi->elt2->bits[bi->word_no];
467
          if (bi->bits)
468
            goto next_bit;
469
          *bit_no += BITMAP_WORD_BITS;
470
          bi->word_no++;
471
        }
472
 
473
      /* Advance to the next identical element.  */
474
      do
475
        {
476
          /* Advance elt1 while it is less than elt2.  We always want
477
             to advance one elt.  */
478
          do
479
            {
480
              bi->elt1 = bi->elt1->next;
481
              if (!bi->elt1)
482
                return false;
483
            }
484
          while (bi->elt1->indx < bi->elt2->indx);
485
 
486
          /* Advance elt2 to be no less than elt1.  This might not
487
             advance.  */
488
          while (bi->elt2->indx < bi->elt1->indx)
489
            {
490
              bi->elt2 = bi->elt2->next;
491
              if (!bi->elt2)
492
                return false;
493
            }
494
        }
495
      while (bi->elt1->indx != bi->elt2->indx);
496
 
497
      *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
498
      bi->word_no = 0;
499
    }
500
}
501
 
502
/* Advance to the next nonzero bit in the intersection of
503
   complemented bitmaps.  We will have already advanced past the just
504
   iterated bit.  */
505
 
506
static inline bool
507
bmp_iter_and_compl (bitmap_iterator *bi, unsigned *bit_no)
508
{
509
  /* If our current word is nonzero, it contains the bit we want.  */
510
  if (bi->bits)
511
    {
512
    next_bit:
513
      while (!(bi->bits & 1))
514
        {
515
          bi->bits >>= 1;
516
          *bit_no += 1;
517
        }
518
      return true;
519
    }
520
 
521
  /* Round up to the word boundary.  We might have just iterated past
522
     the end of the last word, hence the -1.  It is not possible for
523
     bit_no to point at the beginning of the now last word.  */
524
  *bit_no = ((*bit_no + BITMAP_WORD_BITS - 1)
525
             / BITMAP_WORD_BITS * BITMAP_WORD_BITS);
526
  bi->word_no++;
527
 
528
  while (1)
529
    {
530
      /* Find the next nonzero word in this elt.  */
531
      while (bi->word_no != BITMAP_ELEMENT_WORDS)
532
        {
533
          bi->bits = bi->elt1->bits[bi->word_no];
534
          if (bi->elt2 && bi->elt2->indx == bi->elt1->indx)
535
            bi->bits &= ~bi->elt2->bits[bi->word_no];
536
          if (bi->bits)
537
            goto next_bit;
538
          *bit_no += BITMAP_WORD_BITS;
539
          bi->word_no++;
540
        }
541
 
542
      /* Advance to the next element of elt1.  */
543
      bi->elt1 = bi->elt1->next;
544
      if (!bi->elt1)
545
        return false;
546
 
547
      /* Advance elt2 until it is no less than elt1.  */
548
      while (bi->elt2 && bi->elt2->indx < bi->elt1->indx)
549
        bi->elt2 = bi->elt2->next;
550
 
551
      *bit_no = bi->elt1->indx * BITMAP_ELEMENT_ALL_BITS;
552
      bi->word_no = 0;
553
    }
554
}
555
 
556
/* Loop over all bits set in BITMAP, starting with MIN and setting
557
   BITNUM to the bit number.  ITER is a bitmap iterator.  BITNUM
558
   should be treated as a read-only variable as it contains loop
559
   state.  */
560
 
561
#define EXECUTE_IF_SET_IN_BITMAP(BITMAP, MIN, BITNUM, ITER)             \
562
  for (bmp_iter_set_init (&(ITER), (BITMAP), (MIN), &(BITNUM));         \
563
       bmp_iter_set (&(ITER), &(BITNUM));                               \
564
       bmp_iter_next (&(ITER), &(BITNUM)))
565
 
566
/* Loop over all the bits set in BITMAP1 & BITMAP2, starting with MIN
567
   and setting BITNUM to the bit number.  ITER is a bitmap iterator.
568
   BITNUM should be treated as a read-only variable as it contains
569
   loop state.  */
570
 
571
#define EXECUTE_IF_AND_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER)   \
572
  for (bmp_iter_and_init (&(ITER), (BITMAP1), (BITMAP2), (MIN),         \
573
                          &(BITNUM));                                   \
574
       bmp_iter_and (&(ITER), &(BITNUM));                               \
575
       bmp_iter_next (&(ITER), &(BITNUM)))
576
 
577
/* Loop over all the bits set in BITMAP1 & ~BITMAP2, starting with MIN
578
   and setting BITNUM to the bit number.  ITER is a bitmap iterator.
579
   BITNUM should be treated as a read-only variable as it contains
580
   loop state.  */
581
 
582
#define EXECUTE_IF_AND_COMPL_IN_BITMAP(BITMAP1, BITMAP2, MIN, BITNUM, ITER) \
583
  for (bmp_iter_and_compl_init (&(ITER), (BITMAP1), (BITMAP2), (MIN),   \
584
                                &(BITNUM));                             \
585
       bmp_iter_and_compl (&(ITER), &(BITNUM));                         \
586
       bmp_iter_next (&(ITER), &(BITNUM)))
587
 
588
#endif /* GCC_BITMAP_H */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.