lib/lbitset.c

   1 /* Functions to support link list bitsets.
   2
   3    Copyright (C) 2002-2004, 2006, 2009-2012 Free Software Foundation,
   4    Inc.
   5
   6    Contributed by Michael Hayes (m.hayes@elec.canterbury.ac.nz).
   7
   8    This program is free software: you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation, either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include <config.h>
  22
  23 #include "lbitset.h"
  24
  25 #include "obstack.h"
  26 #include <stddef.h>
  27 #include <stdlib.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30
  31 /* This file implements linked-list bitsets.  These bitsets can be of
  32    arbitrary length and are more efficient than arrays of bits for
  33    large sparse sets.
  34
  35    Usually if all the bits in an element are zero we remove the element
  36    from the list.  However, a side effect of the bit caching is that we
  37    do not always notice when an element becomes zero.  Hence the
  38    lbitset_weed function which removes zero elements.  */
  39
  40
  41 /* Number of words to use for each element.  The larger the value the
  42    greater the size of the cache and the shorter the time to find a given bit
  43    but the more memory wasted for sparse bitsets and the longer the time
  44    to search for set bits.
  45
  46    The routines that dominate timing profiles are lbitset_elt_find
  47    and lbitset_elt_link, especially when accessing the bits randomly.  */
  48
  49 #define LBITSET_ELT_WORDS 2
  50
  51 typedef bitset_word lbitset_word;
  52
  53 #define LBITSET_WORD_BITS BITSET_WORD_BITS
  54
  55 /* Number of bits stored in each element.  */
  56 #define LBITSET_ELT_BITS \
  57   ((unsigned int) (LBITSET_ELT_WORDS * LBITSET_WORD_BITS))
  58
  59 /* Lbitset element.   We use an array of bits for each element.
  60    These are linked together in a doubly-linked list.  */
  61 typedef struct lbitset_elt_struct
  62 {
  63   struct lbitset_elt_struct *next;      /* Next element.  */
  64   struct lbitset_elt_struct *prev;      /* Previous element.  */
  65   bitset_windex index;  /* bitno / BITSET_WORD_BITS.  */
  66   bitset_word words[LBITSET_ELT_WORDS]; /* Bits that are set.  */
  67 }
  68 lbitset_elt;
  69
  70
  71 enum lbitset_find_mode
  72   { LBITSET_FIND, LBITSET_CREATE, LBITSET_SUBST };
  73
  74 static lbitset_elt lbitset_zero_elts[3]; /* Elements of all zero bits.  */
  75
  76 /* Obstack to allocate bitset elements from.  */
  77 static struct obstack lbitset_obstack;
  78 static bool lbitset_obstack_init = false;
  79 static lbitset_elt *lbitset_free_list;  /* Free list of bitset elements.  */
  80
  81 extern void debug_lbitset (bitset);
  82
  83 #define LBITSET_CURRENT1(X) \
  84   ((lbitset_elt *) (void *) ((char *) (X) - offsetof (lbitset_elt, words)))
  85
  86 #define LBITSET_CURRENT(X) LBITSET_CURRENT1((X)->b.cdata)
  87
  88 #define LBITSET_HEAD(X) ((X)->l.head)
  89 #define LBITSET_TAIL(X) ((X)->l.tail)
  90
  91 /* Allocate a lbitset element.  The bits are not cleared.  */
  92 static inline lbitset_elt *
  93 lbitset_elt_alloc (void)
  94 {
  95   lbitset_elt *elt;
  96
  97   if (lbitset_free_list != 0)
  98     {
  99       elt = lbitset_free_list;
 100       lbitset_free_list = elt->next;
 101     }
 102   else
 103     {
 104       if (!lbitset_obstack_init)
 105         {
 106           lbitset_obstack_init = true;
 107
 108           /* Let particular systems override the size of a chunk.  */
 109
 110 #ifndef OBSTACK_CHUNK_SIZE
 111 #define OBSTACK_CHUNK_SIZE 0
 112 #endif
 113
 114           /* Let them override the alloc and free routines too.  */
 115
 116 #ifndef OBSTACK_CHUNK_ALLOC
 117 #define OBSTACK_CHUNK_ALLOC xmalloc
 118 #endif
 119
 120 #ifndef OBSTACK_CHUNK_FREE
 121 #define OBSTACK_CHUNK_FREE free
 122 #endif
 123
 124 #if ! defined __GNUC__ || __GNUC__ < 2
 125 #define __alignof__(type) 0
 126 #endif
 127
 128           obstack_specify_allocation (&lbitset_obstack, OBSTACK_CHUNK_SIZE,
 129                                       __alignof__ (lbitset_elt),
 130                                       OBSTACK_CHUNK_ALLOC,
 131                                       OBSTACK_CHUNK_FREE);
 132         }
 133
 134       /* Perhaps we should add a number of new elements to the free
 135          list.  */
 136       elt = (lbitset_elt *) obstack_alloc (&lbitset_obstack,
 137                                            sizeof (lbitset_elt));
 138     }
 139
 140   return elt;
 141 }
 142
 143
 144 /* Allocate a lbitset element.  The bits are cleared.  */
 145 static inline lbitset_elt *
 146 lbitset_elt_calloc (void)
 147 {
 148   lbitset_elt *elt;
 149
 150   elt = lbitset_elt_alloc ();
 151   memset (elt->words, 0, sizeof (elt->words));
 152   return elt;
 153 }
 154
 155
 156 static inline void
 157 lbitset_elt_free (lbitset_elt *elt)
 158 {
 159   elt->next = lbitset_free_list;
 160   lbitset_free_list = elt;
 161 }
 162
 163
 164 /* Unlink element ELT from bitset BSET.  */
 165 static inline void
 166 lbitset_elt_unlink (bitset bset, lbitset_elt *elt)
 167 {
 168   lbitset_elt *next = elt->next;
 169   lbitset_elt *prev = elt->prev;
 170
 171   if (prev)
 172     prev->next = next;
 173
 174   if (next)
 175     next->prev = prev;
 176
 177   if (LBITSET_HEAD (bset) == elt)
 178     LBITSET_HEAD (bset) = next;
 179   if (LBITSET_TAIL (bset) == elt)
 180     LBITSET_TAIL (bset) = prev;
 181
 182   /* Update cache pointer.  Since the first thing we try is to insert
 183      before current, make current the next entry in preference to the
 184      previous.  */
 185   if (LBITSET_CURRENT (bset) == elt)
 186     {
 187       if (next)
 188         {
 189           bset->b.cdata = next->words;
 190           bset->b.cindex = next->index;
 191         }
 192       else if (prev)
 193         {
 194           bset->b.cdata = prev->words;
 195           bset->b.cindex = prev->index;
 196         }
 197       else
 198         {
 199           bset->b.csize = 0;
 200           bset->b.cdata = 0;
 201         }
 202     }
 203
 204   lbitset_elt_free (elt);
 205 }
 206
 207
 208 /* Cut the chain of bitset BSET before element ELT and free the
 209    elements.  */
 210 static inline void
 211 lbitset_prune (bitset bset, lbitset_elt *elt)
 212 {
 213   lbitset_elt *next;
 214
 215   if (!elt)
 216     return;
 217
 218   if (elt->prev)
 219     {
 220       LBITSET_TAIL (bset) = elt->prev;
 221       bset->b.cdata = elt->prev->words;
 222       bset->b.cindex = elt->prev->index;
 223       elt->prev->next = 0;
 224     }
 225   else
 226     {
 227       LBITSET_HEAD (bset) = 0;
 228       LBITSET_TAIL (bset) = 0;
 229       bset->b.cdata = 0;
 230       bset->b.csize = 0;
 231     }
 232
 233   for (; elt; elt = next)
 234     {
 235       next = elt->next;
 236       lbitset_elt_free (elt);
 237     }
 238 }
 239
 240
 241 /* Are all bits in an element zero?  */
 242 static inline bool
 243 lbitset_elt_zero_p (lbitset_elt *elt)
 244 {
 245   int i;
 246
 247   for (i = 0; i < LBITSET_ELT_WORDS; i++)
 248     if (elt->words[i])
 249       return false;
 250
 251   return true;
 252 }
 253
 254
 255 /* Link the bitset element into the current bitset linked list.  */
 256 static inline void
 257 lbitset_elt_link (bitset bset, lbitset_elt *elt)
 258 {
 259   bitset_windex windex = elt->index;
 260   lbitset_elt *ptr;
 261   lbitset_elt *current;
 262
 263   if (bset->b.csize)
 264     current = LBITSET_CURRENT (bset);
 265   else
 266     current = LBITSET_HEAD (bset);
 267
 268   /* If this is the first and only element, add it in.  */
 269   if (LBITSET_HEAD (bset) == 0)
 270     {
 271       elt->next = elt->prev = 0;
 272       LBITSET_HEAD (bset) = elt;
 273       LBITSET_TAIL (bset) = elt;
 274     }
 275
 276   /* If this index is less than that of the current element, it goes
 277      somewhere before the current element.  */
 278   else if (windex < bset->b.cindex)
 279     {
 280       for (ptr = current;
 281            ptr->prev && ptr->prev->index > windex; ptr = ptr->prev)
 282         continue;
 283
 284       if (ptr->prev)
 285         ptr->prev->next = elt;
 286       else
 287         LBITSET_HEAD (bset) = elt;
 288
 289       elt->prev = ptr->prev;
 290       elt->next = ptr;
 291       ptr->prev = elt;
 292     }
 293
 294   /* Otherwise, it must go somewhere after the current element.  */
 295   else
 296     {
 297       for (ptr = current;
 298            ptr->next && ptr->next->index < windex; ptr = ptr->next)
 299         continue;
 300
 301       if (ptr->next)
 302         ptr->next->prev = elt;
 303       else
 304         LBITSET_TAIL (bset) = elt;
 305
 306       elt->next = ptr->next;
 307       elt->prev = ptr;
 308       ptr->next = elt;
 309     }
 310
 311   /* Set up so this is the first element searched.  */
 312   bset->b.cindex = windex;
 313   bset->b.csize = LBITSET_ELT_WORDS;
 314   bset->b.cdata = elt->words;
 315 }
 316
 317
 318 static lbitset_elt *
 319 lbitset_elt_find (bitset bset, bitset_windex windex,
 320                   enum lbitset_find_mode mode)
 321 {
 322   lbitset_elt *elt;
 323   lbitset_elt *current;
 324
 325   if (bset->b.csize)
 326     {
 327       current = LBITSET_CURRENT (bset);
 328       /* Check if element is the cached element.  */
 329       if ((windex - bset->b.cindex) < bset->b.csize)
 330         return current;
 331     }
 332   else
 333     {
 334       current = LBITSET_HEAD (bset);
 335     }
 336
 337   if (current)
 338     {
 339       if (windex < bset->b.cindex)
 340         {
 341           for (elt = current;
 342                elt->prev && elt->index > windex; elt = elt->prev)
 343             continue;
 344         }
 345       else
 346         {
 347           for (elt = current;
 348                elt->next && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
 349                elt = elt->next)
 350             continue;
 351         }
 352
 353       /* ELT is the nearest to the one we want.  If it's not the one
 354          we want, the one we want does not exist.  */
 355       if (elt && (windex - elt->index) < LBITSET_ELT_WORDS)
 356         {
 357           bset->b.cindex = elt->index;
 358           bset->b.csize = LBITSET_ELT_WORDS;
 359           bset->b.cdata = elt->words;
 360           return elt;
 361         }
 362     }
 363
 364   switch (mode)
 365     {
 366     default:
 367       abort ();
 368
 369     case LBITSET_FIND:
 370       return 0;
 371
 372     case LBITSET_CREATE:
 373       windex -= windex % LBITSET_ELT_WORDS;
 374
 375       elt = lbitset_elt_calloc ();
 376       elt->index = windex;
 377       lbitset_elt_link (bset, elt);
 378       return elt;
 379
 380     case LBITSET_SUBST:
 381       return &lbitset_zero_elts[0];
 382     }
 383 }
 384
 385
 386 /* Weed out the zero elements from the list.  */
 387 static inline void
 388 lbitset_weed (bitset bset)
 389 {
 390   lbitset_elt *elt;
 391   lbitset_elt *next;
 392
 393   for (elt = LBITSET_HEAD (bset); elt; elt = next)
 394     {
 395       next = elt->next;
 396       if (lbitset_elt_zero_p (elt))
 397         lbitset_elt_unlink (bset, elt);
 398     }
 399 }
 400
 401
 402 /* Set all bits in the bitset to zero.  */
 403 static void
 404 lbitset_zero (bitset bset)
 405 {
 406   lbitset_elt *head;
 407
 408   head = LBITSET_HEAD (bset);
 409   if (!head)
 410     return;
 411
 412   /* Clear a bitset by freeing the linked list at the head element.  */
 413   lbitset_prune (bset, head);
 414 }
 415
 416
 417 /* Is DST == SRC?  */
 418 static inline bool
 419 lbitset_equal_p (bitset dst, bitset src)
 420 {
 421   lbitset_elt *selt;
 422   lbitset_elt *delt;
 423   int j;
 424
 425   if (src == dst)
 426     return true;
 427
 428   lbitset_weed (src);
 429   lbitset_weed (dst);
 430   for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
 431        selt && delt; selt = selt->next, delt = delt->next)
 432     {
 433       if (selt->index != delt->index)
 434         return false;
 435
 436       for (j = 0; j < LBITSET_ELT_WORDS; j++)
 437         if (delt->words[j] != selt->words[j])
 438           return false;
 439     }
 440   return !selt && !delt;
 441 }
 442
 443
 444 /* Copy bits from bitset SRC to bitset DST.  */
 445 static inline void
 446 lbitset_copy (bitset dst, bitset src)
 447 {
 448   lbitset_elt *elt;
 449   lbitset_elt *head;
 450   lbitset_elt *prev;
 451   lbitset_elt *tmp;
 452
 453   if (src == dst)
 454     return;
 455
 456   lbitset_zero (dst);
 457
 458   head = LBITSET_HEAD (src);
 459   if (!head)
 460     return;
 461
 462   prev = 0;
 463   for (elt = head; elt; elt = elt->next)
 464     {
 465       tmp = lbitset_elt_alloc ();
 466       tmp->index = elt->index;
 467       tmp->prev = prev;
 468       tmp->next = 0;
 469       if (prev)
 470         prev->next = tmp;
 471       else
 472         LBITSET_HEAD (dst) = tmp;
 473       prev = tmp;
 474
 475       memcpy (tmp->words, elt->words, sizeof (elt->words));
 476     }
 477   LBITSET_TAIL (dst) = tmp;
 478
 479   dst->b.csize = LBITSET_ELT_WORDS;
 480   dst->b.cdata = LBITSET_HEAD (dst)->words;
 481   dst->b.cindex = LBITSET_HEAD (dst)->index;
 482 }
 483
 484
 485 /* Copy bits from bitset SRC to bitset DST.  Return true if
 486    bitsets different.  */
 487 static inline bool
 488 lbitset_copy_cmp (bitset dst, bitset src)
 489 {
 490   if (src == dst)
 491     return false;
 492
 493   if (!LBITSET_HEAD (dst))
 494     {
 495       lbitset_copy (dst, src);
 496       return LBITSET_HEAD (src) != 0;
 497     }
 498
 499   if (lbitset_equal_p (dst, src))
 500     return false;
 501
 502   lbitset_copy (dst, src);
 503   return true;
 504 }
 505
 506
 507 static bitset_bindex
 508 lbitset_resize (bitset src, bitset_bindex size)
 509 {
 510     BITSET_NBITS_ (src) = size;
 511
 512     /* Need to prune any excess bits.  FIXME.  */
 513     return size;
 514 }
 515
 516 /* Set bit BITNO in bitset DST.  */
 517 static void
 518 lbitset_set (bitset dst, bitset_bindex bitno)
 519 {
 520   bitset_windex windex = bitno / BITSET_WORD_BITS;
 521
 522   lbitset_elt_find (dst, windex, LBITSET_CREATE);
 523
 524   dst->b.cdata[windex - dst->b.cindex] |=
 525     (bitset_word) 1 << (bitno % BITSET_WORD_BITS);
 526 }
 527
 528
 529 /* Reset bit BITNO in bitset DST.  */
 530 static void
 531 lbitset_reset (bitset dst, bitset_bindex bitno)
 532 {
 533   bitset_windex windex = bitno / BITSET_WORD_BITS;
 534
 535   if (!lbitset_elt_find (dst, windex, LBITSET_FIND))
 536     return;
 537
 538   dst->b.cdata[windex - dst->b.cindex] &=
 539     ~((bitset_word) 1 << (bitno % BITSET_WORD_BITS));
 540
 541   /* If all the data is zero, perhaps we should unlink it now...  */
 542 }
 543
 544
 545 /* Test bit BITNO in bitset SRC.  */
 546 static bool
 547 lbitset_test (bitset src, bitset_bindex bitno)
 548 {
 549   bitset_windex windex = bitno / BITSET_WORD_BITS;
 550
 551   return (lbitset_elt_find (src, windex, LBITSET_FIND)
 552           && ((src->b.cdata[windex - src->b.cindex]
 553                >> (bitno % BITSET_WORD_BITS))
 554               & 1));
 555 }
 556
 557
 558 static void
 559 lbitset_free (bitset bset)
 560 {
 561   lbitset_zero (bset);
 562 }
 563
 564
 565 /* Find list of up to NUM bits set in BSET starting from and including
 566  *NEXT and store in array LIST.  Return with actual number of bits
 567  found and with *NEXT indicating where search stopped.  */
 568 static bitset_bindex
 569 lbitset_list_reverse (bitset bset, bitset_bindex *list,
 570                       bitset_bindex num, bitset_bindex *next)
 571 {
 572   bitset_bindex rbitno;
 573   bitset_bindex bitno;
 574   unsigned int bcount;
 575   bitset_bindex boffset;
 576   bitset_windex windex;
 577   bitset_bindex count;
 578   lbitset_elt *elt;
 579   bitset_word word;
 580   bitset_bindex n_bits;
 581
 582   elt = LBITSET_TAIL (bset);
 583   if (!elt)
 584     return 0;
 585
 586   n_bits = (elt->index + LBITSET_ELT_WORDS) * BITSET_WORD_BITS;
 587   rbitno = *next;
 588
 589   if (rbitno >= n_bits)
 590     return 0;
 591
 592   bitno = n_bits - (rbitno + 1);
 593
 594   windex = bitno / BITSET_WORD_BITS;
 595
 596   /* Skip back to starting element.  */
 597   for (; elt && elt->index > windex; elt = elt->prev)
 598     continue;
 599
 600   if (!elt)
 601     return 0;
 602
 603   if (windex >= elt->index + LBITSET_ELT_WORDS)
 604     {
 605       /* We are trying to start in no-mans land so start
 606          at end of current elt.  */
 607       bcount = BITSET_WORD_BITS - 1;
 608       windex = elt->index + LBITSET_ELT_WORDS - 1;
 609     }
 610   else
 611     {
 612       bcount = bitno % BITSET_WORD_BITS;
 613     }
 614
 615   count = 0;
 616   boffset = windex * BITSET_WORD_BITS;
 617
 618   /* If num is 1, we could speed things up with a binary search
 619      of the word of interest.  */
 620
 621   while (elt)
 622     {
 623       bitset_word *srcp = elt->words;
 624
 625       for (; (windex - elt->index) < LBITSET_ELT_WORDS;
 626            windex--, boffset -= BITSET_WORD_BITS,
 627              bcount = BITSET_WORD_BITS - 1)
 628         {
 629           word =
 630             srcp[windex - elt->index] << (BITSET_WORD_BITS - 1 - bcount);
 631
 632           for (; word; bcount--)
 633             {
 634               if (word & BITSET_MSB)
 635                 {
 636                   list[count++] = boffset + bcount;
 637                   if (count >= num)
 638                     {
 639                       *next = n_bits - (boffset + bcount);
 640                       return count;
 641                     }
 642                 }
 643               word <<= 1;
 644             }
 645         }
 646
 647       elt = elt->prev;
 648       if (elt)
 649         {
 650           windex = elt->index + LBITSET_ELT_WORDS - 1;
 651           boffset = windex * BITSET_WORD_BITS;
 652         }
 653     }
 654
 655   *next = n_bits - (boffset + 1);
 656   return count;
 657 }
 658
 659
 660 /* Find list of up to NUM bits set in BSET starting from and including
 661  *NEXT and store in array LIST.  Return with actual number of bits
 662  found and with *NEXT indicating where search stopped.  */
 663 static bitset_bindex
 664 lbitset_list (bitset bset, bitset_bindex *list,
 665               bitset_bindex num, bitset_bindex *next)
 666 {
 667   bitset_bindex bitno;
 668   bitset_windex windex;
 669   bitset_bindex count;
 670   lbitset_elt *elt;
 671   lbitset_elt *head;
 672   bitset_word word;
 673
 674   head = LBITSET_HEAD (bset);
 675   if (!head)
 676     return 0;
 677
 678   bitno = *next;
 679   count = 0;
 680
 681   if (!bitno)
 682     {
 683       /* This is the most common case.  */
 684
 685       /* Start with the first element.  */
 686       elt = head;
 687       windex = elt->index;
 688       bitno = windex * BITSET_WORD_BITS;
 689     }
 690   else
 691     {
 692       windex = bitno / BITSET_WORD_BITS;
 693
 694       /* Skip to starting element.  */
 695       for (elt = head;
 696            elt && (elt->index + LBITSET_ELT_WORDS - 1) < windex;
 697            elt = elt->next)
 698         continue;
 699
 700       if (!elt)
 701         return 0;
 702
 703       if (windex < elt->index)
 704         {
 705           windex = elt->index;
 706           bitno = windex * BITSET_WORD_BITS;
 707         }
 708       else
 709         {
 710           bitset_word *srcp = elt->words;
 711
 712           /* We are starting within an element.  */
 713
 714           for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
 715             {
 716               word = srcp[windex - elt->index] >> (bitno % BITSET_WORD_BITS);
 717
 718               for (; word; bitno++)
 719                 {
 720                   if (word & 1)
 721                     {
 722                       list[count++] = bitno;
 723                       if (count >= num)
 724                         {
 725                           *next = bitno + 1;
 726                           return count;
 727                         }
 728                     }
 729                   word >>= 1;
 730                 }
 731               bitno = (windex + 1) * BITSET_WORD_BITS;
 732             }
 733
 734           elt = elt->next;
 735           if (elt)
 736             {
 737               windex = elt->index;
 738               bitno = windex * BITSET_WORD_BITS;
 739             }
 740         }
 741     }
 742
 743
 744   /* If num is 1, we could speed things up with a binary search
 745      of the word of interest.  */
 746
 747   while (elt)
 748     {
 749       int i;
 750       bitset_word *srcp = elt->words;
 751
 752       if ((count + LBITSET_ELT_BITS) < num)
 753         {
 754           /* The coast is clear, plant boot!  */
 755
 756 #if LBITSET_ELT_WORDS == 2
 757           word = srcp[0];
 758           if (word)
 759             {
 760               if (!(word & 0xffff))
 761                 {
 762                   word >>= 16;
 763                   bitno += 16;
 764                 }
 765               if (!(word & 0xff))
 766                 {
 767                   word >>= 8;
 768                   bitno += 8;
 769                 }
 770               for (; word; bitno++)
 771                 {
 772                   if (word & 1)
 773                     list[count++] = bitno;
 774                   word >>= 1;
 775                 }
 776             }
 777           windex++;
 778           bitno = windex * BITSET_WORD_BITS;
 779
 780           word = srcp[1];
 781           if (word)
 782             {
 783               if (!(word & 0xffff))
 784                 {
 785                   word >>= 16;
 786                   bitno += 16;
 787                 }
 788               for (; word; bitno++)
 789                 {
 790                   if (word & 1)
 791                     list[count++] = bitno;
 792                   word >>= 1;
 793                 }
 794             }
 795           windex++;
 796           bitno = windex * BITSET_WORD_BITS;
 797 #else
 798           for (i = 0; i < LBITSET_ELT_WORDS; i++)
 799             {
 800               word = srcp[i];
 801               if (word)
 802                 {
 803                   if (!(word & 0xffff))
 804                     {
 805                       word >>= 16;
 806                       bitno += 16;
 807                     }
 808                   if (!(word & 0xff))
 809                     {
 810                       word >>= 8;
 811                       bitno += 8;
 812                     }
 813                   for (; word; bitno++)
 814                     {
 815                       if (word & 1)
 816                         list[count++] = bitno;
 817                       word >>= 1;
 818                     }
 819                 }
 820               windex++;
 821               bitno = windex * BITSET_WORD_BITS;
 822             }
 823 #endif
 824         }
 825       else
 826         {
 827           /* Tread more carefully since we need to check
 828              if array overflows.  */
 829
 830           for (i = 0; i < LBITSET_ELT_WORDS; i++)
 831             {
 832               for (word = srcp[i]; word; bitno++)
 833                 {
 834                   if (word & 1)
 835                     {
 836                       list[count++] = bitno;
 837                       if (count >= num)
 838                         {
 839                           *next = bitno + 1;
 840                           return count;
 841                         }
 842                     }
 843                   word >>= 1;
 844                 }
 845               windex++;
 846               bitno = windex * BITSET_WORD_BITS;
 847             }
 848         }
 849
 850       elt = elt->next;
 851       if (elt)
 852         {
 853           windex = elt->index;
 854           bitno = windex * BITSET_WORD_BITS;
 855         }
 856     }
 857
 858   *next = bitno;
 859   return count;
 860 }
 861
 862
 863 static bool
 864 lbitset_empty_p (bitset dst)
 865 {
 866   lbitset_elt *elt;
 867   lbitset_elt *next;
 868
 869   for (elt = LBITSET_HEAD (dst); elt; elt = next)
 870     {
 871       next = elt->next;
 872       if (!lbitset_elt_zero_p (elt))
 873         return 0;
 874       /* Weed as we go.  */
 875       lbitset_elt_unlink (dst, elt);
 876     }
 877
 878   return 1;
 879 }
 880
 881
 882 /* Ensure that any unused bits within the last element are clear.  */
 883 static inline void
 884 lbitset_unused_clear (bitset dst)
 885 {
 886   unsigned int last_bit;
 887   bitset_bindex n_bits;
 888
 889   n_bits = BITSET_SIZE_ (dst);
 890   last_bit = n_bits % LBITSET_ELT_BITS;
 891
 892   if (last_bit)
 893     {
 894       lbitset_elt *elt;
 895       bitset_windex windex;
 896       bitset_word *srcp;
 897
 898       elt = LBITSET_TAIL (dst);
 899       srcp = elt->words;
 900       windex = n_bits / BITSET_WORD_BITS;
 901
 902       srcp[windex - elt->index] &= ((bitset_word) 1 << last_bit) - 1;
 903       windex++;
 904
 905       for (; (windex - elt->index) < LBITSET_ELT_WORDS; windex++)
 906         srcp[windex - elt->index] = 0;
 907     }
 908 }
 909
 910
 911 static void
 912 lbitset_ones (bitset dst)
 913 {
 914   bitset_windex i;
 915   bitset_windex windex;
 916   lbitset_elt *elt;
 917
 918   /* This is a decidedly unfriendly operation for a linked list
 919       bitset!  It makes a sparse bitset become dense.  An alternative
 920       is to have a flag that indicates that the bitset stores the
 921       complement of what it indicates.  */
 922
 923   windex = (BITSET_SIZE_ (dst) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS;
 924
 925   for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
 926     {
 927       /* Create new elements if they cannot be found.  */
 928       elt = lbitset_elt_find (dst, i, LBITSET_CREATE);
 929       memset (elt->words, -1, sizeof (elt->words));
 930     }
 931
 932   lbitset_unused_clear (dst);
 933 }
 934
 935
 936 static void
 937 lbitset_not (bitset dst, bitset src)
 938 {
 939   lbitset_elt *selt;
 940   lbitset_elt *delt;
 941   bitset_windex i;
 942   unsigned int j;
 943   bitset_windex windex;
 944
 945   windex = (BITSET_SIZE_ (dst) + BITSET_WORD_BITS - 1) / BITSET_WORD_BITS;
 946
 947   for (i = 0; i < windex; i += LBITSET_ELT_WORDS)
 948     {
 949       /* Create new elements for dst if they cannot be found
 950          or substitute zero elements if src elements not found.  */
 951       selt = lbitset_elt_find (src, i, LBITSET_SUBST);
 952       delt = lbitset_elt_find (dst, i, LBITSET_CREATE);
 953
 954       for (j = 0; j < LBITSET_ELT_WORDS; j++)
 955         delt->words[j] = ~selt->words[j];
 956     }
 957   lbitset_unused_clear (dst);
 958   lbitset_weed (dst);
 959   return;
 960 }
 961
 962
 963 /* Is DST == DST | SRC?  */
 964 static bool
 965 lbitset_subset_p (bitset dst, bitset src)
 966 {
 967   lbitset_elt *selt;
 968   lbitset_elt *delt;
 969   unsigned int j;
 970
 971   for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
 972        selt || delt; selt = selt->next, delt = delt->next)
 973     {
 974       if (!selt)
 975         selt = &lbitset_zero_elts[0];
 976       else if (!delt)
 977         delt = &lbitset_zero_elts[0];
 978       else if (selt->index != delt->index)
 979         {
 980           if (selt->index < delt->index)
 981             {
 982               lbitset_zero_elts[2].next = delt;
 983               delt = &lbitset_zero_elts[2];
 984             }
 985           else
 986             {
 987               lbitset_zero_elts[1].next = selt;
 988               selt = &lbitset_zero_elts[1];
 989             }
 990         }
 991
 992       for (j = 0; j < LBITSET_ELT_WORDS; j++)
 993         if (delt->words[j] != (selt->words[j] | delt->words[j]))
 994           return false;
 995     }
 996   return true;
 997 }
 998
 999
1000 /* Is DST & SRC == 0?  */
1001 static bool
1002 lbitset_disjoint_p (bitset dst, bitset src)
1003 {
1004   lbitset_elt *selt;
1005   lbitset_elt *delt;
1006   unsigned int j;
1007
1008   for (selt = LBITSET_HEAD (src), delt = LBITSET_HEAD (dst);
1009        selt && delt; selt = selt->next, delt = delt->next)
1010     {
1011       if (selt->index != delt->index)
1012         {
1013           if (selt->index < delt->index)
1014             {
1015               lbitset_zero_elts[2].next = delt;
1016               delt = &lbitset_zero_elts[2];
1017             }
1018           else
1019             {
1020               lbitset_zero_elts[1].next = selt;
1021               selt = &lbitset_zero_elts[1];
1022             }
1023           /* Since the elements are different, there is no
1024              intersection of these elements.  */
1025           continue;
1026         }
1027
1028       for (j = 0; j < LBITSET_ELT_WORDS; j++)
1029         if (selt->words[j] & delt->words[j])
1030           return false;
1031     }
1032   return true;
1033 }
1034
1035
1036 static bool
1037 lbitset_op3_cmp (bitset dst, bitset src1, bitset src2, enum bitset_ops op)
1038 {
1039   lbitset_elt *selt1 = LBITSET_HEAD (src1);
1040   lbitset_elt *selt2 = LBITSET_HEAD (src2);
1041   lbitset_elt *delt = LBITSET_HEAD (dst);
1042   bitset_windex windex1;
1043   bitset_windex windex2;
1044   bitset_windex windex;
1045   lbitset_elt *stmp1;
1046   lbitset_elt *stmp2;
1047   lbitset_elt *dtmp;
1048   bitset_word *srcp1;
1049   bitset_word *srcp2;
1050   bitset_word *dstp;
1051   bool changed = false;
1052   unsigned int i;
1053
1054   LBITSET_HEAD (dst) = 0;
1055   dst->b.csize = 0;
1056
1057   windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
1058   windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
1059
1060   while (selt1 || selt2)
1061     {
1062       /* Figure out whether we need to substitute zero elements for
1063          missing links.  */
1064       if (windex1 == windex2)
1065         {
1066           windex = windex1;
1067           stmp1 = selt1;
1068           stmp2 = selt2;
1069           selt1 = selt1->next;
1070           windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
1071           selt2 = selt2->next;
1072           windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
1073         }
1074       else if (windex1 < windex2)
1075         {
1076           windex = windex1;
1077           stmp1 = selt1;
1078           stmp2 = &lbitset_zero_elts[0];
1079           selt1 = selt1->next;
1080           windex1 = (selt1) ? selt1->index : BITSET_WINDEX_MAX;
1081         }
1082       else
1083         {
1084           windex = windex2;
1085           stmp1 = &lbitset_zero_elts[0];
1086           stmp2 = selt2;
1087           selt2 = selt2->next;
1088           windex2 = (selt2) ? selt2->index : BITSET_WINDEX_MAX;
1089         }
1090
1091       /* Find the appropriate element from DST.  Begin by discarding
1092          elements that we've skipped.  */
1093       while (delt && delt->index < windex)
1094         {
1095           changed = true;
1096           dtmp = delt;
1097           delt = delt->next;
1098           lbitset_elt_free (dtmp);
1099         }
1100       if (delt && delt->index == windex)
1101         {
1102           dtmp = delt;
1103           delt = delt->next;
1104         }
1105       else
1106         dtmp = lbitset_elt_calloc ();
1107
1108       /* Do the operation, and if any bits are set, link it into the
1109          linked list.  */
1110       srcp1 = stmp1->words;
1111       srcp2 = stmp2->words;
1112       dstp = dtmp->words;
1113       switch (op)
1114         {
1115         default:
1116           abort ();
1117
1118         case BITSET_OP_OR:
1119           for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
1120             {
1121               bitset_word tmp = *srcp1++ | *srcp2++;
1122
1123               if (*dstp != tmp)
1124                 {
1125                   changed = true;
1126                   *dstp = tmp;
1127                 }
1128             }
1129           break;
1130
1131         case BITSET_OP_AND:
1132           for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
1133             {
1134               bitset_word tmp = *srcp1++ & *srcp2++;
1135
1136               if (*dstp != tmp)
1137                 {
1138                   changed = true;
1139                   *dstp = tmp;
1140                 }
1141             }
1142           break;
1143
1144         case BITSET_OP_XOR:
1145           for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
1146             {
1147               bitset_word tmp = *srcp1++ ^ *srcp2++;
1148
1149               if (*dstp != tmp)
1150                 {
1151                   changed = true;
1152                   *dstp = tmp;
1153                 }
1154             }
1155           break;
1156
1157         case BITSET_OP_ANDN:
1158           for (i = 0; i < LBITSET_ELT_WORDS; i++, dstp++)
1159             {
1160               bitset_word tmp = *srcp1++ & ~(*srcp2++);
1161
1162               if (*dstp != tmp)
1163                 {
1164                   changed = true;
1165                   *dstp = tmp;
1166                 }
1167             }
1168           break;
1169         }
1170
1171       if (!lbitset_elt_zero_p (dtmp))
1172         {
1173           dtmp->index = windex;
1174           /* Perhaps this could be optimised...  */
1175           lbitset_elt_link (dst, dtmp);
1176         }
1177       else
1178         {
1179           lbitset_elt_free (dtmp);
1180         }
1181     }
1182
1183   /* If we have elements of DST left over, free them all.  */
1184   if (delt)
1185     {
1186       changed = true;
1187       lbitset_prune (dst, delt);
1188     }
1189
1190   return changed;
1191 }
1192
1193
1194 static bool
1195 lbitset_and_cmp (bitset dst, bitset src1, bitset src2)
1196 {
1197   lbitset_elt *selt1 = LBITSET_HEAD (src1);
1198   lbitset_elt *selt2 = LBITSET_HEAD (src2);
1199   bool changed;
1200
1201   if (!selt2)
1202     {
1203       lbitset_weed (dst);
1204       changed = !LBITSET_HEAD (dst);
1205       lbitset_zero (dst);
1206       return changed;
1207     }
1208   else if (!selt1)
1209     {
1210       lbitset_weed (dst);
1211       changed = !LBITSET_HEAD (dst);
1212       lbitset_zero (dst);
1213       return changed;
1214     }
1215   return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_AND);
1216 }
1217
1218
1219 static void
1220 lbitset_and (bitset dst, bitset src1, bitset src2)
1221 {
1222   lbitset_and_cmp (dst, src1, src2);
1223 }
1224
1225
1226 static bool
1227 lbitset_andn_cmp (bitset dst, bitset src1, bitset src2)
1228 {
1229   lbitset_elt *selt1 = LBITSET_HEAD (src1);
1230   lbitset_elt *selt2 = LBITSET_HEAD (src2);
1231   bool changed;
1232
1233   if (!selt2)
1234     {
1235       return lbitset_copy_cmp (dst, src1);
1236     }
1237   else if (!selt1)
1238     {
1239       lbitset_weed (dst);
1240       changed = !LBITSET_HEAD (dst);
1241       lbitset_zero (dst);
1242       return changed;
1243     }
1244   return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_ANDN);
1245 }
1246
1247
1248 static void
1249 lbitset_andn (bitset dst, bitset src1, bitset src2)
1250 {
1251   lbitset_andn_cmp (dst, src1, src2);
1252 }
1253
1254
1255 static bool
1256 lbitset_or_cmp (bitset dst, bitset src1, bitset src2)
1257 {
1258   lbitset_elt *selt1 = LBITSET_HEAD (src1);
1259   lbitset_elt *selt2 = LBITSET_HEAD (src2);
1260
1261   if (!selt2)
1262     {
1263       return lbitset_copy_cmp (dst, src1);
1264     }
1265   else if (!selt1)
1266     {
1267       return lbitset_copy_cmp (dst, src2);
1268     }
1269   return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_OR);
1270 }
1271
1272
1273 static void
1274 lbitset_or (bitset dst, bitset src1, bitset src2)
1275 {
1276   lbitset_or_cmp (dst, src1, src2);
1277 }
1278
1279
1280 static bool
1281 lbitset_xor_cmp (bitset dst, bitset src1, bitset src2)
1282 {
1283   lbitset_elt *selt1 = LBITSET_HEAD (src1);
1284   lbitset_elt *selt2 = LBITSET_HEAD (src2);
1285
1286   if (!selt2)
1287     {
1288       return lbitset_copy_cmp (dst, src1);
1289     }
1290   else if (!selt1)
1291     {
1292       return lbitset_copy_cmp (dst, src2);
1293     }
1294   return lbitset_op3_cmp (dst, src1, src2, BITSET_OP_XOR);
1295 }
1296
1297
1298 static void
1299 lbitset_xor (bitset dst, bitset src1, bitset src2)
1300 {
1301   lbitset_xor_cmp (dst, src1, src2);
1302 }
1303
1304
1305
1306 /* Vector of operations for linked-list bitsets.  */
1307 struct bitset_vtable lbitset_vtable = {
1308   lbitset_set,
1309   lbitset_reset,
1310   bitset_toggle_,
1311   lbitset_test,
1312   lbitset_resize,
1313   bitset_size_,
1314   bitset_count_,
1315   lbitset_empty_p,
1316   lbitset_ones,
1317   lbitset_zero,
1318   lbitset_copy,
1319   lbitset_disjoint_p,
1320   lbitset_equal_p,
1321   lbitset_not,
1322   lbitset_subset_p,
1323   lbitset_and,
1324   lbitset_and_cmp,
1325   lbitset_andn,
1326   lbitset_andn_cmp,
1327   lbitset_or,
1328   lbitset_or_cmp,
1329   lbitset_xor,
1330   lbitset_xor_cmp,
1331   bitset_and_or_,
1332   bitset_and_or_cmp_,
1333   bitset_andn_or_,
1334   bitset_andn_or_cmp_,
1335   bitset_or_and_,
1336   bitset_or_and_cmp_,
1337   lbitset_list,
1338   lbitset_list_reverse,
1339   lbitset_free,
1340   BITSET_LIST
1341 };
1342
1343
1344 /* Return size of initial structure.  */
1345 size_t
1346 lbitset_bytes (bitset_bindex n_bits ATTRIBUTE_UNUSED)
1347 {
1348   return sizeof (struct lbitset_struct);
1349 }
1350
1351
1352 /* Initialize a bitset.  */
1353 bitset
1354 lbitset_init (bitset bset, bitset_bindex n_bits ATTRIBUTE_UNUSED)
1355 {
1356   BITSET_NBITS_ (bset) = n_bits;
1357   bset->b.vtable = &lbitset_vtable;
1358   return bset;
1359 }
1360
1361
1362 void
1363 lbitset_release_memory (void)
1364 {
1365   lbitset_free_list = 0;
1366   if (lbitset_obstack_init)
1367     {
1368       lbitset_obstack_init = false;
1369       obstack_free (&lbitset_obstack, NULL);
1370     }
1371 }
1372
1373
1374 /* Function to be called from debugger to debug lbitset.  */
1375 void
1376 debug_lbitset (bitset bset)
1377 {
1378   lbitset_elt *elt;
1379   unsigned int i;
1380
1381   if (!bset)
1382     return;
1383
1384   for (elt = LBITSET_HEAD (bset); elt; elt = elt->next)
1385     {
1386       fprintf (stderr, "Elt %lu\n", (unsigned long int) elt->index);
1387       for (i = 0; i < LBITSET_ELT_WORDS; i++)
1388         {
1389           unsigned int j;
1390           bitset_word word;
1391
1392           word = elt->words[i];
1393
1394           fprintf (stderr, "  Word %u:", i);
1395           for (j = 0; j < LBITSET_WORD_BITS; j++)
1396             if ((word & ((bitset_word) 1 << j)))
1397               fprintf (stderr, " %u", j);
1398           fprintf (stderr, "\n");
1399         }
1400     }
1401 }