Home | History | Annotate | Download | only in helgrind
      1 
      2 /*--------------------------------------------------------------------*/
      3 /*--- Sets of words, with unique set identifiers.                  ---*/
      4 /*---                                                 hg_wordset.c ---*/
      5 /*--------------------------------------------------------------------*/
      6 
      7 /*
      8    This file is part of Helgrind, a Valgrind tool for detecting errors
      9    in threaded programs.
     10 
     11    Copyright (C) 2007-2015 OpenWorks LLP
     12        info (at) open-works.co.uk
     13 
     14    This program is free software; you can redistribute it and/or
     15    modify it under the terms of the GNU General Public License as
     16    published by the Free Software Foundation; either version 2 of the
     17    License, or (at your option) any later version.
     18 
     19    This program is distributed in the hope that it will be useful, but
     20    WITHOUT ANY WARRANTY; without even the implied warranty of
     21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     22    General Public License for more details.
     23 
     24    You should have received a copy of the GNU General Public License
     25    along with this program; if not, write to the Free Software
     26    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
     27    02111-1307, USA.
     28 
     29    The GNU General Public License is contained in the file COPYING.
     30 
     31    Neither the names of the U.S. Department of Energy nor the
     32    University of California nor the names of its contributors may be
     33    used to endorse or promote products derived from this software
     34    without prior written permission.
     35 */
     36 
     37 #include "pub_tool_basics.h"
     38 #include "pub_tool_libcassert.h"
     39 #include "pub_tool_libcbase.h"
     40 #include "pub_tool_libcprint.h"
     41 #include "pub_tool_threadstate.h"
     42 #include "pub_tool_wordfm.h"
     43 
     44 #include "hg_basics.h"
     45 #include "hg_wordset.h"     /* self */
     46 
     47 // define to 1 to have (a lot of) debugging of add/re-use/die WSU entries.
     48 #define HG_DEBUG 0
     49 
     50 //------------------------------------------------------------------//
     51 //--- Word Cache                                                 ---//
     52 //------------------------------------------------------------------//
     53 
     54 typedef
     55    struct { UWord arg1; UWord arg2; UWord res; }
     56    WCacheEnt;
     57 
     58 /* Each cache is a fixed sized array of N_WCACHE_STAT_MAX entries.
     59    However only the first .dynMax are used.  This is because at some
     60    point, expanding the cache further overall gives a slowdown because
     61    searching more entries more than negates any performance advantage
     62    from caching those entries in the first place.  Hence use .dynMax
     63    to allow the size of the cache(s) to be set differently for each
     64    different WordSetU. */
     65 #define N_WCACHE_STAT_MAX 32
     66 typedef
     67    struct {
     68       WCacheEnt ent[N_WCACHE_STAT_MAX];
     69       UWord     dynMax; /* 1 .. N_WCACHE_STAT_MAX inclusive */
     70       UWord     inUse;  /* 0 .. dynMax inclusive */
     71    }
     72    WCache;
     73 
     74 #define WCache_INIT(_zzcache,_zzdynmax)                              \
     75    do {                                                              \
     76       tl_assert((_zzdynmax) >= 1);                                   \
     77       tl_assert((_zzdynmax) <= N_WCACHE_STAT_MAX);                   \
     78       (_zzcache).dynMax = (_zzdynmax);                               \
     79       (_zzcache).inUse = 0;                                          \
     80    } while (0)
     81 
     82 #define WCache_LOOKUP_AND_RETURN(_retty,_zzcache,_zzarg1,_zzarg2)    \
     83    do {                                                              \
     84       UWord   _i;                                                    \
     85       UWord   _arg1  = (UWord)(_zzarg1);                             \
     86       UWord   _arg2  = (UWord)(_zzarg2);                             \
     87       WCache* _cache = &(_zzcache);                                  \
     88       tl_assert(_cache->dynMax >= 1);                                \
     89       tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX);                \
     90       tl_assert(_cache->inUse >= 0);                                 \
     91       tl_assert(_cache->inUse <= _cache->dynMax);                    \
     92       if (_cache->inUse > 0) {                                       \
     93          if (_cache->ent[0].arg1 == _arg1                            \
     94              && _cache->ent[0].arg2 == _arg2)                        \
     95             return (_retty)_cache->ent[0].res;                       \
     96          for (_i = 1; _i < _cache->inUse; _i++) {                    \
     97             if (_cache->ent[_i].arg1 == _arg1                        \
     98                 && _cache->ent[_i].arg2 == _arg2) {                  \
     99                WCacheEnt tmp     = _cache->ent[_i-1];                \
    100                _cache->ent[_i-1] = _cache->ent[_i];                  \
    101                _cache->ent[_i]   = tmp;                              \
    102                return (_retty)_cache->ent[_i-1].res;                 \
    103             }                                                        \
    104          }                                                           \
    105       }                                                              \
    106    } while (0)
    107 
    108 #define WCache_UPDATE(_zzcache,_zzarg1,_zzarg2,_zzresult)            \
    109    do {                                                              \
    110       Word    _i;                                                    \
    111       UWord   _arg1  = (UWord)(_zzarg1);                             \
    112       UWord   _arg2  = (UWord)(_zzarg2);                             \
    113       UWord   _res   = (UWord)(_zzresult);                           \
    114       WCache* _cache = &(_zzcache);                                  \
    115       tl_assert(_cache->dynMax >= 1);                                \
    116       tl_assert(_cache->dynMax <= N_WCACHE_STAT_MAX);                \
    117       tl_assert(_cache->inUse >= 0);                                 \
    118       tl_assert(_cache->inUse <= _cache->dynMax);                    \
    119       if (_cache->inUse < _cache->dynMax)                            \
    120          _cache->inUse++;                                            \
    121       for (_i = _cache->inUse-1; _i >= 1; _i--)                      \
    122          _cache->ent[_i] = _cache->ent[_i-1];                        \
    123       _cache->ent[0].arg1 = _arg1;                                   \
    124       _cache->ent[0].arg2 = _arg2;                                   \
    125       _cache->ent[0].res  = _res;                                    \
    126    } while (0)
    127 
    128 
    129 //------------------------------------------------------------------//
    130 //---                          WordSet                           ---//
    131 //---                       Implementation                       ---//
    132 //------------------------------------------------------------------//
    133 
    134 typedef
    135    struct {
    136       WordSetU* owner; /* for sanity checking */
    137       UWord*    words;
    138       UWord     size; /* Really this should be SizeT */
    139    }
    140    WordVec;
    141 
    142 /* ix2vec[0 .. ix2vec_used-1] are pointers to the lock sets (WordVecs)
    143    really.  vec2ix is the inverse mapping, mapping WordVec* to the
    144    corresponding ix2vec entry number.  The two mappings are mutually
    145    redundant.
    146 
    147    If a WordVec WV is marked as dead by HG(dieWS), WV is removed from
    148    vec2ix. The entry of the dead WVs in ix2vec are used to maintain a
    149    linked list of free (to be re-used) ix2vec entries. */
    150 struct _WordSetU {
    151       void*     (*alloc)(const HChar*,SizeT);
    152       const HChar* cc;
    153       void      (*dealloc)(void*);
    154       WordFM*   vec2ix; /* WordVec-to-WordSet mapping tree */
    155       WordVec** ix2vec; /* WordSet-to-WordVec mapping array */
    156       UWord     ix2vec_size;
    157       UWord     ix2vec_used;
    158       WordVec** ix2vec_free;
    159       WordSet   empty; /* cached, for speed */
    160       /* Caches for some operations */
    161       WCache    cache_addTo;
    162       WCache    cache_delFrom;
    163       WCache    cache_intersect;
    164       WCache    cache_minus;
    165       /* Stats */
    166       UWord     n_add;
    167       UWord     n_add_uncached;
    168       UWord     n_del;
    169       UWord     n_del_uncached;
    170       UWord     n_die;
    171       UWord     n_union;
    172       UWord     n_intersect;
    173       UWord     n_intersect_uncached;
    174       UWord     n_minus;
    175       UWord     n_minus_uncached;
    176       UWord     n_elem;
    177       UWord     n_doubleton;
    178       UWord     n_isEmpty;
    179       UWord     n_isSingleton;
    180       UWord     n_anyElementOf;
    181       UWord     n_isSubsetOf;
    182    };
    183 
    184 /* Create a new WordVec of the given size. */
    185 
    186 static WordVec* new_WV_of_size ( WordSetU* wsu, UWord sz )
    187 {
    188    WordVec* wv;
    189    tl_assert(sz >= 0);
    190    wv = wsu->alloc( wsu->cc, sizeof(WordVec) );
    191    wv->owner = wsu;
    192    wv->words = NULL;
    193    wv->size = sz;
    194    if (sz > 0) {
    195      wv->words = wsu->alloc( wsu->cc, (SizeT)sz * sizeof(UWord) );
    196    }
    197    return wv;
    198 }
    199 
    200 static void delete_WV ( WordVec* wv )
    201 {
    202    void (*dealloc)(void*) = wv->owner->dealloc;
    203    if (wv->words) {
    204       dealloc(wv->words);
    205    }
    206    dealloc(wv);
    207 }
    208 static void delete_WV_for_FM ( UWord wv ) {
    209    delete_WV( (WordVec*)wv );
    210 }
    211 
    212 static Word cmp_WordVecs_for_FM ( UWord wv1W, UWord wv2W )
    213 {
    214    UWord    i;
    215    WordVec* wv1    = (WordVec*)wv1W;
    216    WordVec* wv2    = (WordVec*)wv2W;
    217 
    218    // WordVecs with smaller size are smaller.
    219    if (wv1->size < wv2->size) {
    220       return -1;
    221    }
    222    if (wv1->size > wv2->size) {
    223       return 1;
    224    }
    225 
    226    // Sizes are equal => order based on content.
    227    for (i = 0; i < wv1->size; i++) {
    228       if (wv1->words[i] == wv2->words[i])
    229          continue;
    230       if (wv1->words[i] < wv2->words[i])
    231          return -1;
    232       if (wv1->words[i] > wv2->words[i])
    233          return 1;
    234       tl_assert(0);
    235    }
    236    return 0; /* identical */
    237 }
    238 
    239 static void ensure_ix2vec_space ( WordSetU* wsu )
    240 {
    241    UInt      i, new_sz;
    242    WordVec** new_vec;
    243    tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
    244    if (wsu->ix2vec_used < wsu->ix2vec_size)
    245       return;
    246    new_sz = 2 * wsu->ix2vec_size;
    247    if (new_sz == 0) new_sz = 1;
    248    new_vec = wsu->alloc( wsu->cc, new_sz * sizeof(WordVec*) );
    249    tl_assert(new_vec);
    250    for (i = 0; i < wsu->ix2vec_size; i++)
    251       new_vec[i] = wsu->ix2vec[i];
    252    if (wsu->ix2vec)
    253       wsu->dealloc(wsu->ix2vec);
    254    wsu->ix2vec = new_vec;
    255    wsu->ix2vec_size = new_sz;
    256 }
    257 
    258 /* True if wv is a dead entry (i.e. is in the linked list of free to be re-used
    259    entries in ix2vec). */
    260 static inline Bool is_dead ( WordSetU* wsu, WordVec* wv )
    261 {
    262    if (wv == NULL) /* last element in free linked list in ix2vec */
    263       return True;
    264    else
    265       return (WordVec**)wv >= &(wsu->ix2vec[1])
    266          &&  (WordVec**)wv < &(wsu->ix2vec[wsu->ix2vec_size]);
    267 }
    268 /* Index into a WordSetU, doing the obvious range check.  Failure of
    269    the assertions marked XXX and YYY is an indication of passing the
    270    wrong WordSetU* in the public API of this module.
    271    Accessing a dead ws will assert. */
    272 static WordVec* do_ix2vec ( WordSetU* wsu, WordSet ws )
    273 {
    274    WordVec* wv;
    275    tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
    276    if (wsu->ix2vec_used > 0)
    277       tl_assert(wsu->ix2vec);
    278    /* If this assertion fails, it may mean you supplied a 'ws'
    279       that does not come from the 'wsu' universe. */
    280    tl_assert(ws < wsu->ix2vec_used); /* XXX */
    281    wv = wsu->ix2vec[ws];
    282    /* Make absolutely sure that 'ws' is a non dead member of 'wsu'. */
    283    tl_assert(wv);
    284    tl_assert(!is_dead(wsu,wv));
    285    tl_assert(wv->owner == wsu); /* YYY */
    286    return wv;
    287 }
    288 
    289 /* Same as do_ix2vec but returns NULL for a dead ws. */
    290 static WordVec* do_ix2vec_with_dead ( WordSetU* wsu, WordSet ws )
    291 {
    292    WordVec* wv;
    293    tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
    294    if (wsu->ix2vec_used > 0)
    295       tl_assert(wsu->ix2vec);
    296    /* If this assertion fails, it may mean you supplied a 'ws'
    297       that does not come from the 'wsu' universe. */
    298    tl_assert(ws < wsu->ix2vec_used); /* XXX */
    299    wv = wsu->ix2vec[ws];
    300    /* Make absolutely sure that 'ws' is either dead or a member of 'wsu'. */
    301    if (is_dead(wsu,wv))
    302       wv = NULL;
    303    else
    304       tl_assert(wv->owner == wsu); /* YYY */
    305    return wv;
    306 }
    307 
    308 /* See if wv is contained within wsu.  If so, deallocate wv and return
    309    the index of the already-present copy.  If not, add wv to both the
    310    vec2ix and ix2vec mappings and return its index.
    311 */
    312 static WordSet add_or_dealloc_WordVec( WordSetU* wsu, WordVec* wv_new )
    313 {
    314    Bool     have;
    315    WordVec* wv_old;
    316    UWord/*Set*/ ix_old = -1;
    317    /* Really WordSet, but need something that can safely be casted to
    318       a Word* in the lookupFM.  Making it WordSet (which is 32 bits)
    319       causes failures on a 64-bit platform. */
    320    tl_assert(wv_new->owner == wsu);
    321    have = VG_(lookupFM)( wsu->vec2ix,
    322                          (UWord*)&wv_old, (UWord*)&ix_old,
    323                          (UWord)wv_new );
    324    if (have) {
    325       tl_assert(wv_old != wv_new);
    326       tl_assert(wv_old);
    327       tl_assert(wv_old->owner == wsu);
    328       tl_assert(ix_old < wsu->ix2vec_used);
    329       tl_assert(wsu->ix2vec[ix_old] == wv_old);
    330       delete_WV( wv_new );
    331       return (WordSet)ix_old;
    332    } else if (wsu->ix2vec_free) {
    333       WordSet ws;
    334       tl_assert(is_dead(wsu,(WordVec*)wsu->ix2vec_free));
    335       ws = wsu->ix2vec_free - &(wsu->ix2vec[0]);
    336       tl_assert(wsu->ix2vec[ws] == NULL || is_dead(wsu,wsu->ix2vec[ws]));
    337       wsu->ix2vec_free = (WordVec **) wsu->ix2vec[ws];
    338       wsu->ix2vec[ws] = wv_new;
    339       VG_(addToFM)( wsu->vec2ix, (UWord)wv_new, ws );
    340       if (HG_DEBUG) VG_(printf)("aodW %s re-use free %d %p\n", wsu->cc, (Int)ws, wv_new );
    341       return ws;
    342    } else {
    343       ensure_ix2vec_space( wsu );
    344       tl_assert(wsu->ix2vec);
    345       tl_assert(wsu->ix2vec_used < wsu->ix2vec_size);
    346       wsu->ix2vec[wsu->ix2vec_used] = wv_new;
    347       VG_(addToFM)( wsu->vec2ix, (Word)wv_new, (Word)wsu->ix2vec_used );
    348       if (HG_DEBUG) VG_(printf)("aodW %s %d %p\n", wsu->cc, (Int)wsu->ix2vec_used, wv_new  );
    349       wsu->ix2vec_used++;
    350       tl_assert(wsu->ix2vec_used <= wsu->ix2vec_size);
    351       return (WordSet)(wsu->ix2vec_used - 1);
    352    }
    353 }
    354 
    355 
    356 WordSetU* HG_(newWordSetU) ( void* (*alloc_nofail)( const HChar*, SizeT ),
    357                              const HChar* cc,
    358                              void  (*dealloc)(void*),
    359                              Word  cacheSize )
    360 {
    361    WordSetU* wsu;
    362    WordVec*  empty;
    363 
    364    wsu          = alloc_nofail( cc, sizeof(WordSetU) );
    365    VG_(memset)( wsu, 0, sizeof(WordSetU) );
    366    wsu->alloc   = alloc_nofail;
    367    wsu->cc      = cc;
    368    wsu->dealloc = dealloc;
    369    wsu->vec2ix  = VG_(newFM)( alloc_nofail, cc,
    370                               dealloc, cmp_WordVecs_for_FM );
    371    wsu->ix2vec_used = 0;
    372    wsu->ix2vec_size = 0;
    373    wsu->ix2vec      = NULL;
    374    wsu->ix2vec_free = NULL;
    375    WCache_INIT(wsu->cache_addTo,     cacheSize);
    376    WCache_INIT(wsu->cache_delFrom,   cacheSize);
    377    WCache_INIT(wsu->cache_intersect, cacheSize);
    378    WCache_INIT(wsu->cache_minus,     cacheSize);
    379    empty = new_WV_of_size( wsu, 0 );
    380    wsu->empty = add_or_dealloc_WordVec( wsu, empty );
    381 
    382    return wsu;
    383 }
    384 
    385 void HG_(deleteWordSetU) ( WordSetU* wsu )
    386 {
    387    void (*dealloc)(void*) = wsu->dealloc;
    388    tl_assert(wsu->vec2ix);
    389    VG_(deleteFM)( wsu->vec2ix, delete_WV_for_FM, NULL/*val-finalizer*/ );
    390    if (wsu->ix2vec)
    391       dealloc(wsu->ix2vec);
    392    dealloc(wsu);
    393 }
    394 
    395 WordSet HG_(emptyWS) ( WordSetU* wsu )
    396 {
    397    return wsu->empty;
    398 }
    399 
    400 Bool HG_(isEmptyWS) ( WordSetU* wsu, WordSet ws )
    401 {
    402    WordVec* wv = do_ix2vec( wsu, ws );
    403    wsu->n_isEmpty++;
    404    if (wv->size == 0) {
    405       tl_assert(ws == wsu->empty);
    406       return True;
    407    } else {
    408       tl_assert(ws != wsu->empty);
    409       return False;
    410    }
    411 }
    412 
    413 Bool HG_(isSingletonWS) ( WordSetU* wsu, WordSet ws, UWord w )
    414 {
    415    WordVec* wv;
    416    tl_assert(wsu);
    417    wsu->n_isSingleton++;
    418    wv = do_ix2vec( wsu, ws );
    419    return (Bool)(wv->size == 1 && wv->words[0] == w);
    420 }
    421 
    422 UWord HG_(cardinalityWS) ( WordSetU* wsu, WordSet ws )
    423 {
    424    WordVec* wv;
    425    tl_assert(wsu);
    426    wv = do_ix2vec( wsu, ws );
    427    tl_assert(wv->size >= 0);
    428    return wv->size;
    429 }
    430 
    431 UWord HG_(anyElementOfWS) ( WordSetU* wsu, WordSet ws )
    432 {
    433    WordVec* wv;
    434    tl_assert(wsu);
    435    wsu->n_anyElementOf++;
    436    wv = do_ix2vec( wsu, ws );
    437    tl_assert(wv->size >= 1);
    438    return wv->words[0];
    439 }
    440 
    441 UWord HG_(cardinalityWSU) ( WordSetU* wsu )
    442 {
    443    tl_assert(wsu);
    444    return wsu->ix2vec_used;
    445 }
    446 
    447 void HG_(getPayloadWS) ( /*OUT*/UWord** words, /*OUT*/UWord* nWords,
    448                          WordSetU* wsu, WordSet ws )
    449 {
    450    WordVec* wv;
    451    if (HG_DEBUG) VG_(printf)("getPayloadWS %s %d\n", wsu->cc, (Int)ws);
    452    tl_assert(wsu);
    453    wv = do_ix2vec( wsu, ws );
    454    tl_assert(wv->size >= 0);
    455    *nWords = wv->size;
    456    *words  = wv->words;
    457 }
    458 
    459 void HG_(dieWS) ( WordSetU* wsu, WordSet ws )
    460 {
    461    WordVec* wv = do_ix2vec_with_dead( wsu, ws );
    462    WordVec* wv_in_vec2ix;
    463    UWord/*Set*/ wv_ix = -1;
    464 
    465    if (HG_DEBUG) VG_(printf)("dieWS %s %d %p\n", wsu->cc, (Int)ws, wv);
    466 
    467    if (ws == 0)
    468       return; // we never die the empty set.
    469 
    470    if (!wv)
    471       return; // already dead. (or a bug ?).
    472 
    473    wsu->n_die++;
    474 
    475 
    476    wsu->ix2vec[ws] = (WordVec*) wsu->ix2vec_free;
    477    wsu->ix2vec_free = &wsu->ix2vec[ws];
    478 
    479    VG_(delFromFM) ( wsu->vec2ix,
    480                     (UWord*)&wv_in_vec2ix, (UWord*)&wv_ix,
    481                     (UWord)wv );
    482 
    483    if (HG_DEBUG) VG_(printf)("dieWS wv_ix %d\n", (Int)wv_ix);
    484    tl_assert (wv_ix);
    485    tl_assert (wv_ix == ws);
    486 
    487    delete_WV( wv );
    488 
    489    wsu->cache_addTo.inUse = 0;
    490    wsu->cache_delFrom.inUse = 0;
    491    wsu->cache_intersect.inUse = 0;
    492    wsu->cache_minus.inUse = 0;
    493 }
    494 
    495 Bool HG_(plausibleWS) ( WordSetU* wsu, WordSet ws )
    496 {
    497    if (wsu == NULL) return False;
    498    if (ws < 0 || ws >= wsu->ix2vec_used)
    499       return False;
    500    return True;
    501 }
    502 
    503 Bool HG_(saneWS_SLOW) ( WordSetU* wsu, WordSet ws )
    504 {
    505    WordVec* wv;
    506    UWord    i;
    507    if (wsu == NULL) return False;
    508    if (ws < 0 || ws >= wsu->ix2vec_used)
    509       return False;
    510    wv = do_ix2vec( wsu, ws );
    511    /* can never happen .. do_ix2vec will assert instead.  Oh well. */
    512    if (wv->owner != wsu) return False;
    513    if (wv->size < 0) return False;
    514    if (wv->size > 0) {
    515       for (i = 0; i < wv->size-1; i++) {
    516          if (wv->words[i] >= wv->words[i+1])
    517             return False;
    518       }
    519    }
    520    return True;
    521 }
    522 
    523 Bool HG_(elemWS) ( WordSetU* wsu, WordSet ws, UWord w )
    524 {
    525    UWord    i;
    526    WordVec* wv = do_ix2vec( wsu, ws );
    527    wsu->n_elem++;
    528    for (i = 0; i < wv->size; i++) {
    529       if (wv->words[i] == w)
    530          return True;
    531    }
    532    return False;
    533 }
    534 
    535 WordSet HG_(doubletonWS) ( WordSetU* wsu, UWord w1, UWord w2 )
    536 {
    537    WordVec* wv;
    538    wsu->n_doubleton++;
    539    if (w1 == w2) {
    540       wv = new_WV_of_size(wsu, 1);
    541       wv->words[0] = w1;
    542    }
    543    else if (w1 < w2) {
    544       wv = new_WV_of_size(wsu, 2);
    545       wv->words[0] = w1;
    546       wv->words[1] = w2;
    547    }
    548    else {
    549       tl_assert(w1 > w2);
    550       wv = new_WV_of_size(wsu, 2);
    551       wv->words[0] = w2;
    552       wv->words[1] = w1;
    553    }
    554    return add_or_dealloc_WordVec( wsu, wv );
    555 }
    556 
    557 WordSet HG_(singletonWS) ( WordSetU* wsu, UWord w )
    558 {
    559    return HG_(doubletonWS)( wsu, w, w );
    560 }
    561 
    562 WordSet HG_(isSubsetOf) ( WordSetU* wsu, WordSet small, WordSet big )
    563 {
    564    wsu->n_isSubsetOf++;
    565    return small == HG_(intersectWS)( wsu, small, big );
    566 }
    567 
    568 void HG_(ppWS) ( WordSetU* wsu, WordSet ws )
    569 {
    570    UWord    i;
    571    WordVec* wv;
    572    tl_assert(wsu);
    573    wv = do_ix2vec( wsu, ws );
    574    VG_(printf)("{");
    575    for (i = 0; i < wv->size; i++) {
    576       VG_(printf)("%p", (void*)wv->words[i]);
    577       if (i < wv->size-1)
    578          VG_(printf)(",");
    579    }
    580    VG_(printf)("}");
    581 }
    582 
    583 void HG_(ppWSUstats) ( WordSetU* wsu, const HChar* name )
    584 {
    585    VG_(printf)("   WordSet \"%s\":\n", name);
    586    VG_(printf)("      addTo        %10lu (%lu uncached)\n",
    587                wsu->n_add, wsu->n_add_uncached);
    588    VG_(printf)("      delFrom      %10lu (%lu uncached)\n",
    589                wsu->n_del, wsu->n_del_uncached);
    590    VG_(printf)("      union        %10lu\n", wsu->n_union);
    591    VG_(printf)("      intersect    %10lu (%lu uncached) "
    592                "[nb. incl isSubsetOf]\n",
    593                wsu->n_intersect, wsu->n_intersect_uncached);
    594    VG_(printf)("      minus        %10lu (%lu uncached)\n",
    595                wsu->n_minus, wsu->n_minus_uncached);
    596    VG_(printf)("      elem         %10lu\n",   wsu->n_elem);
    597    VG_(printf)("      doubleton    %10lu\n",   wsu->n_doubleton);
    598    VG_(printf)("      isEmpty      %10lu\n",   wsu->n_isEmpty);
    599    VG_(printf)("      isSingleton  %10lu\n",   wsu->n_isSingleton);
    600    VG_(printf)("      anyElementOf %10lu\n",   wsu->n_anyElementOf);
    601    VG_(printf)("      isSubsetOf   %10lu\n",   wsu->n_isSubsetOf);
    602    VG_(printf)("      dieWS        %10lu\n",   wsu->n_die);
    603 }
    604 
    605 WordSet HG_(addToWS) ( WordSetU* wsu, WordSet ws, UWord w )
    606 {
    607    UWord    k, j;
    608    WordVec* wv_new;
    609    WordVec* wv;
    610    WordSet  result = (WordSet)(-1); /* bogus */
    611 
    612    wsu->n_add++;
    613    WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_addTo, ws, w);
    614    wsu->n_add_uncached++;
    615 
    616    /* If already present, this is a no-op. */
    617    wv = do_ix2vec( wsu, ws );
    618    for (k = 0; k < wv->size; k++) {
    619       if (wv->words[k] == w) {
    620          result = ws;
    621          goto out;
    622       }
    623    }
    624    /* Ok, not present.  Build a new one ... */
    625    wv_new = new_WV_of_size( wsu, wv->size + 1 );
    626    k = j = 0;
    627    for (; k < wv->size && wv->words[k] < w; k++) {
    628       wv_new->words[j++] = wv->words[k];
    629    }
    630    wv_new->words[j++] = w;
    631    for (; k < wv->size; k++) {
    632       tl_assert(wv->words[k] > w);
    633       wv_new->words[j++] = wv->words[k];
    634    }
    635    tl_assert(j == wv_new->size);
    636 
    637    /* Find any existing copy, or add the new one. */
    638    result = add_or_dealloc_WordVec( wsu, wv_new );
    639    tl_assert(result != (WordSet)(-1));
    640 
    641   out:
    642    WCache_UPDATE(wsu->cache_addTo, ws, w, result);
    643    return result;
    644 }
    645 
    646 WordSet HG_(delFromWS) ( WordSetU* wsu, WordSet ws, UWord w )
    647 {
    648    UWord    i, j, k;
    649    WordVec* wv_new;
    650    WordSet  result = (WordSet)(-1); /* bogus */
    651    WordVec* wv = do_ix2vec( wsu, ws );
    652 
    653    wsu->n_del++;
    654 
    655    /* special case empty set */
    656    if (wv->size == 0) {
    657       tl_assert(ws == wsu->empty);
    658       return ws;
    659    }
    660 
    661    WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_delFrom, ws, w);
    662    wsu->n_del_uncached++;
    663 
    664    /* If not already present, this is a no-op. */
    665    for (i = 0; i < wv->size; i++) {
    666       if (wv->words[i] == w)
    667          break;
    668    }
    669    if (i == wv->size) {
    670       result = ws;
    671       goto out;
    672    }
    673    /* So w is present in ws, and the new set will be one element
    674       smaller. */
    675    tl_assert(i >= 0 && i < wv->size);
    676    tl_assert(wv->size > 0);
    677 
    678    wv_new = new_WV_of_size( wsu, wv->size - 1 );
    679    j = k = 0;
    680    for (; j < wv->size; j++) {
    681       if (j == i)
    682          continue;
    683       wv_new->words[k++] = wv->words[j];
    684    }
    685    tl_assert(k == wv_new->size);
    686 
    687    result = add_or_dealloc_WordVec( wsu, wv_new );
    688    if (wv->size == 1) {
    689       tl_assert(result == wsu->empty);
    690    }
    691 
    692   out:
    693    WCache_UPDATE(wsu->cache_delFrom, ws, w, result);
    694    return result;
    695 }
    696 
    697 WordSet HG_(unionWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
    698 {
    699    UWord    i1, i2, k, sz;
    700    WordVec* wv_new;
    701    WordVec* wv1 = do_ix2vec( wsu, ws1 );
    702    WordVec* wv2 = do_ix2vec( wsu, ws2 );
    703    wsu->n_union++;
    704    sz = 0;
    705    i1 = i2 = 0;
    706    while (1) {
    707       if (i1 >= wv1->size || i2 >= wv2->size)
    708          break;
    709       sz++;
    710       if (wv1->words[i1] < wv2->words[i2]) {
    711          i1++;
    712       } else
    713       if (wv1->words[i1] > wv2->words[i2]) {
    714          i2++;
    715       } else {
    716          i1++;
    717          i2++;
    718       }
    719    }
    720    tl_assert(i1 <= wv1->size);
    721    tl_assert(i2 <= wv2->size);
    722    tl_assert(i1 == wv1->size || i2 == wv2->size);
    723    if (i1 == wv1->size && i2 < wv2->size) {
    724       sz += (wv2->size - i2);
    725    }
    726    if (i2 == wv2->size && i1 < wv1->size) {
    727       sz += (wv1->size - i1);
    728    }
    729 
    730    wv_new = new_WV_of_size( wsu, sz );
    731    k = 0;
    732 
    733    i1 = i2 = 0;
    734    while (1) {
    735       if (i1 >= wv1->size || i2 >= wv2->size)
    736          break;
    737       if (wv1->words[i1] < wv2->words[i2]) {
    738          wv_new->words[k++] = wv1->words[i1];
    739          i1++;
    740       } else
    741       if (wv1->words[i1] > wv2->words[i2]) {
    742          wv_new->words[k++] = wv2->words[i2];
    743          i2++;
    744       } else {
    745          wv_new->words[k++] = wv1->words[i1];
    746          i1++;
    747          i2++;
    748       }
    749    }
    750    tl_assert(i1 <= wv1->size);
    751    tl_assert(i2 <= wv2->size);
    752    tl_assert(i1 == wv1->size || i2 == wv2->size);
    753    if (i1 == wv1->size && i2 < wv2->size) {
    754       while (i2 < wv2->size)
    755          wv_new->words[k++] = wv2->words[i2++];
    756    }
    757    if (i2 == wv2->size && i1 < wv1->size) {
    758       while (i1 < wv1->size)
    759          wv_new->words[k++] = wv1->words[i1++];
    760    }
    761 
    762    tl_assert(k == sz);
    763 
    764    return add_or_dealloc_WordVec( wsu, wv_new );
    765 }
    766 
    767 WordSet HG_(intersectWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
    768 {
    769    UWord    i1, i2, k, sz;
    770    WordSet  ws_new = (WordSet)(-1); /* bogus */
    771    WordVec* wv_new;
    772    WordVec* wv1;
    773    WordVec* wv2;
    774 
    775    wsu->n_intersect++;
    776 
    777    /* Deal with an obvious case fast. */
    778    if (ws1 == ws2)
    779       return ws1;
    780 
    781    /* Since intersect(x,y) == intersect(y,x), convert both variants to
    782       the same query.  This reduces the number of variants the cache
    783       has to deal with. */
    784    if (ws1 > ws2) {
    785       WordSet wst = ws1; ws1 = ws2; ws2 = wst;
    786    }
    787 
    788    WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_intersect, ws1, ws2);
    789    wsu->n_intersect_uncached++;
    790 
    791    wv1 = do_ix2vec( wsu, ws1 );
    792    wv2 = do_ix2vec( wsu, ws2 );
    793    sz = 0;
    794    i1 = i2 = 0;
    795    while (1) {
    796       if (i1 >= wv1->size || i2 >= wv2->size)
    797          break;
    798       if (wv1->words[i1] < wv2->words[i2]) {
    799          i1++;
    800       } else
    801       if (wv1->words[i1] > wv2->words[i2]) {
    802          i2++;
    803       } else {
    804          sz++;
    805          i1++;
    806          i2++;
    807       }
    808    }
    809    tl_assert(i1 <= wv1->size);
    810    tl_assert(i2 <= wv2->size);
    811    tl_assert(i1 == wv1->size || i2 == wv2->size);
    812 
    813    wv_new = new_WV_of_size( wsu, sz );
    814    k = 0;
    815 
    816    i1 = i2 = 0;
    817    while (1) {
    818       if (i1 >= wv1->size || i2 >= wv2->size)
    819          break;
    820       if (wv1->words[i1] < wv2->words[i2]) {
    821          i1++;
    822       } else
    823       if (wv1->words[i1] > wv2->words[i2]) {
    824          i2++;
    825       } else {
    826          wv_new->words[k++] = wv1->words[i1];
    827          i1++;
    828          i2++;
    829       }
    830    }
    831    tl_assert(i1 <= wv1->size);
    832    tl_assert(i2 <= wv2->size);
    833    tl_assert(i1 == wv1->size || i2 == wv2->size);
    834 
    835    tl_assert(k == sz);
    836 
    837    ws_new = add_or_dealloc_WordVec( wsu, wv_new );
    838    if (sz == 0) {
    839       tl_assert(ws_new == wsu->empty);
    840    }
    841 
    842    tl_assert(ws_new != (WordSet)(-1));
    843    WCache_UPDATE(wsu->cache_intersect, ws1, ws2, ws_new);
    844 
    845    return ws_new;
    846 }
    847 
    848 WordSet HG_(minusWS) ( WordSetU* wsu, WordSet ws1, WordSet ws2 )
    849 {
    850    UWord    i1, i2, k, sz;
    851    WordSet  ws_new = (WordSet)(-1); /* bogus */
    852    WordVec* wv_new;
    853    WordVec* wv1;
    854    WordVec* wv2;
    855 
    856    wsu->n_minus++;
    857    WCache_LOOKUP_AND_RETURN(WordSet, wsu->cache_minus, ws1, ws2);
    858    wsu->n_minus_uncached++;
    859 
    860    wv1 = do_ix2vec( wsu, ws1 );
    861    wv2 = do_ix2vec( wsu, ws2 );
    862    sz = 0;
    863    i1 = i2 = 0;
    864    while (1) {
    865       if (i1 >= wv1->size || i2 >= wv2->size)
    866          break;
    867       if (wv1->words[i1] < wv2->words[i2]) {
    868          sz++;
    869          i1++;
    870       } else
    871       if (wv1->words[i1] > wv2->words[i2]) {
    872          i2++;
    873       } else {
    874          i1++;
    875          i2++;
    876       }
    877    }
    878    tl_assert(i1 <= wv1->size);
    879    tl_assert(i2 <= wv2->size);
    880    tl_assert(i1 == wv1->size || i2 == wv2->size);
    881    if (i2 == wv2->size && i1 < wv1->size) {
    882       sz += (wv1->size - i1);
    883    }
    884 
    885    wv_new = new_WV_of_size( wsu, sz );
    886    k = 0;
    887 
    888    i1 = i2 = 0;
    889    while (1) {
    890       if (i1 >= wv1->size || i2 >= wv2->size)
    891          break;
    892       if (wv1->words[i1] < wv2->words[i2]) {
    893          wv_new->words[k++] = wv1->words[i1];
    894          i1++;
    895       } else
    896       if (wv1->words[i1] > wv2->words[i2]) {
    897          i2++;
    898       } else {
    899          i1++;
    900          i2++;
    901       }
    902    }
    903    tl_assert(i1 <= wv1->size);
    904    tl_assert(i2 <= wv2->size);
    905    tl_assert(i1 == wv1->size || i2 == wv2->size);
    906    if (i2 == wv2->size && i1 < wv1->size) {
    907       while (i1 < wv1->size)
    908          wv_new->words[k++] = wv1->words[i1++];
    909    }
    910 
    911    tl_assert(k == sz);
    912 
    913    ws_new = add_or_dealloc_WordVec( wsu, wv_new );
    914    if (sz == 0) {
    915       tl_assert(ws_new == wsu->empty);
    916    }
    917 
    918    tl_assert(ws_new != (WordSet)(-1));
    919    WCache_UPDATE(wsu->cache_minus, ws1, ws2, ws_new);
    920 
    921    return ws_new;
    922 }
    923 
    924 static __attribute__((unused))
    925 void show_WS ( WordSetU* wsu, WordSet ws )
    926 {
    927    UWord i;
    928    WordVec* wv = do_ix2vec( wsu, ws );
    929    VG_(printf)("#%u{", ws);
    930    for (i = 0; i < wv->size; i++) {
    931       VG_(printf)("%lu", wv->words[i]);
    932       if (i < wv->size-1)
    933          VG_(printf)(",");
    934    }
    935    VG_(printf)("}\n");
    936 }
    937 
    938 //------------------------------------------------------------------//
    939 //---                        end WordSet                         ---//
    940 //---                       Implementation                       ---//
    941 //------------------------------------------------------------------//
    942 
    943 /*--------------------------------------------------------------------*/
    944 /*--- end                                             hg_wordset.c ---*/
    945 /*--------------------------------------------------------------------*/
    946