((cite: hotspot/src/share/vm/opto/indexSet.hpp))
    // This file defines the IndexSet class, a set of sparse integer indices.
    // This data structure is used by the compiler in its liveness analysis and
    // during register allocation.

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
    //-------------------------------- class IndexSet ----------------------------
    // An IndexSet is a piece-wise bitvector.  At the top level, we have an array
    // of pointers to bitvector chunks called BitBlocks.  Each BitBlock has a fixed
    // size and is allocated from a shared free list.  The bits which are set in
    // each BitBlock correspond to the elements of the set.

    class IndexSet : public ResourceObj {

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      // When we allocate an IndexSet, it starts off with an array of top level block
      // pointers of a set length.  This size is intended to be large enough for the
      // majority of IndexSets.  In the cases when this size is not large enough,
      // a separately allocated array is used.

      // The length of the preallocated top level block array
      enum { preallocated_block_list_size = 16 };

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      // The number of elements in the set
      uint      _count;

      // Our top level array of bitvector segments
      BitBlock **_blocks;

      BitBlock  *_preallocated_block_list[preallocated_block_list_size];

      // The number of top level array entries in use
      uint       _max_blocks;

      // Our assertions need to know the maximum number allowed in the set
    #ifdef ASSERT
      uint       _max_elements;
    #endif

      // The next IndexSet on the free list (not used at same time as count)
      IndexSet *_next;

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      //------------------------------ class BitBlock ----------------------------
      // The BitBlock class is a segment of a bitvector set.

      class BitBlock : public ResourceObj {

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
        // All of BitBlocks fields and methods are declared private.  We limit
        // access to IndexSet and IndexSetIterator.

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      // Elements of a IndexSet get decomposed into three fields.  The highest order
      // bits are the block index, which tell which high level block holds the element.
      // Within that block, the word index indicates which word holds the element.
      // Finally, the bit index determines which single bit within that word indicates
      // membership of the element in the set.

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
        // Operations.  A BitBlock supports four simple operations,
        // clear(), member(), insert(), and remove().  These methods do
        // not assume that the block index has been masked out.

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      // All IndexSets share an arena from which they allocate BitBlocks.  Unused
      // BitBlocks are placed on a free list.

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
        // A BitBlock is composed of some number of 32 bit words.  When a BitBlock
        // is not in use by any IndexSet, it is stored on a free list.  The next field
        // is used by IndexSet to mainting this free list.

        union {
          uint32 _words[words_per_block];
          BitBlock *_next;
        } _data;

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
      // The lengths of the index bitfields
      enum { bit_index_length = 5,
             word_index_length = 3,
             block_index_length = 8 // not used
      };

      // Derived constants used for manipulating the index bitfields
      enum {
             bit_index_offset = 0, // not used
             word_index_offset = bit_index_length,
             block_index_offset = bit_index_length + word_index_length,

             bits_per_word = 1 << bit_index_length,
             words_per_block = 1 << word_index_length,
             bits_per_block = bits_per_word * words_per_block,

             bit_index_mask = right_n_bits(bit_index_length),
             word_index_mask = right_n_bits(word_index_length)
      };

    ((cite: hotspot/src/share/vm/opto/indexSet.hpp))
    //-------------------------------- class IndexSetIterator --------------------
    // An iterator for IndexSets.

    class IndexSetIterator VALUE_OBJ_CLASS_SPEC {

    ((cite: hotspot/src/share/vm/opto/chaitin.cpp))
          IndexSetIterator elements(s);
          uint lidx;
          while((lidx = elements.next()) != 0) {
    ...
          }