Coverage Report

Created: 2018-07-03 15:31

/home/travis/build/MoarVM/MoarVM/src/strings/uthash.h
Line
Count
Source (jump to first uncovered line)
1
/*
2
Copyright (c) 2003-2014, Troy D. Hanson     http://troydhanson.github.com/uthash/
3
All rights reserved.
4
5
Redistribution and use in source and binary forms, with or without
6
modification, are permitted provided that the following conditions are met:
7
8
    * Redistributions of source code must retain the above copyright
9
      notice, this list of conditions and the following disclaimer.
10
11
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
12
IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
13
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
14
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
15
OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
16
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
17
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
18
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
19
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
20
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22
*/
23
24
/* NOTE: While this started out as a stock uthash.h, by now it has
25
 * undergone numerous changes to more closely integrate it with MoarVM
26
 * strings, remove things MoarVM doesn't need, and not remember the
27
 * insertion order (resulting in changes to iteration code - and a
28
 * memory saving). */
29
30
#ifndef UTHASH_H
31
#define UTHASH_H
32
33
#include <string.h>   /* memcmp,strlen */
34
#include <stddef.h>   /* ptrdiff_t */
35
#include <stdlib.h>   /* exit() */
36
37
/* These macros use decltype or the earlier __typeof GNU extension.
38
   As decltype is only available in newer compilers (VS2010 or gcc 4.3+
39
   when compiling c++ source) this code uses whatever method is needed
40
   or, for VS2008 where neither is available, uses casting workarounds. */
41
#ifdef _MSC_VER         /* MS compiler */
42
#if _MSC_VER >= 1600 && defined(__cplusplus)  /* VS2010 or newer in C++ mode */
43
#define DECLTYPE(x) (decltype(x))
44
#else                   /* VS2008 or older (or VS2010 in C mode) */
45
#define NO_DECLTYPE
46
#define DECLTYPE(x)
47
#endif
48
#else                   /* GNU, Sun and other compilers */
49
59.9M
#define DECLTYPE(x) (__typeof(x))
50
#endif
51
52
#ifdef NO_DECLTYPE
53
#define DECLTYPE_ASSIGN(dst,src)                                                 \
54
do {                                                                             \
55
  char **_da_dst = (char**)(&(dst));                                             \
56
  *_da_dst = (char*)(src);                                                       \
57
} while(0)
58
#else
59
59.9M
#define DECLTYPE_ASSIGN(dst,src)                                                 \
60
59.9M
do {                                                                             \
61
59.9M
  (dst) = DECLTYPE(dst)(src);                                                    \
62
59.9M
} while(0)
63
#endif
64
65
/* a number of the hash function use uint32_t which isn't defined on win32 */
66
#ifdef _MSC_VER
67
typedef unsigned int uint32_t;
68
typedef unsigned char uint8_t;
69
#else
70
#include <inttypes.h>   /* uint32_t */
71
#endif
72
73
#define UTHASH_VERSION 1.9.9
74
75
#ifndef uthash_fatal
76
#error "uthash_fatal not defined"
77
#define uthash_fatal(msg) exit(-1)        /* fatal error (out of memory,etc) */
78
#endif
79
#ifndef uthash_malloc
80
#define uthash_malloc(tc, sz) MVM_fixed_size_alloc(tc, tc->instance->fsa, sz)      /* malloc fcn                      */
81
#endif
82
#ifndef uthash_malloc_zeroed
83
1.28M
#define uthash_malloc_zeroed(tc, sz) MVM_fixed_size_alloc_zeroed(tc, tc->instance->fsa, sz)      /* malloc fcn                      */
84
#endif
85
#ifndef uthash_free
86
375k
#define uthash_free(tc, ptr, sz) MVM_fixed_size_free(tc, tc->instance->fsa, sz, ptr)     /* free fcn                        */
87
#endif
88
89
#ifndef uthash_noexpand_fyi
90
#define uthash_noexpand_fyi(tbl)          /* can be defined to log noexpand  */
91
#endif
92
#ifndef uthash_expand_fyi
93
#define uthash_expand_fyi(tbl)            /* can be defined to log expands   */
94
#endif
95
96
/* initial number of buckets */
97
634k
#define HASH_INITIAL_NUM_BUCKETS 8       /* initial number of buckets        */
98
634k
#define HASH_INITIAL_NUM_BUCKETS_LOG2 3  /* lg2 of initial number of buckets */
99
3.02M
#define HASH_BKT_CAPACITY_THRESH 10      /* expand when bucket count reaches */
100
101
#include "strings/uthash_types.h"
102
void MVM_fixed_size_free(MVMThreadContext *tc, MVMFixedSizeAlloc *fsa, size_t bytes, void *free);
103
void * MVM_fixed_size_alloc(MVMThreadContext *tc, MVMFixedSizeAlloc *fsa, size_t bytes);
104
void * MVM_fixed_size_alloc_zeroed(MVMThreadContext *tc, MVMFixedSizeAlloc *fsa, size_t bytes);
105
/* calculate the element whose hash handle address is hhe */
106
2.39M
#define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
107
18.8k
#define HASH_FIND(hh,head,keyptr,keylen,out)                                     \
108
18.8k
do {                                                                             \
109
18.8k
  MVMhashv _hf_hashv;                                                            \
110
18.8k
  unsigned _hf_bkt;                                                              \
111
18.8k
  out=NULL;                                                                      \
112
18.8k
  if (head) {                                                                    \
113
17.7k
     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt, (head)->hh.tbl->log2_num_buckets); \
114
17.7k
     HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
115
17.7k
                      keyptr,keylen,out,_hf_hashv);                             \
116
17.7k
  }                                                                              \
117
18.8k
} while (0)
118
#define DETERMINE_BUCKET_AND(hashv, num_bkts) \
119
    ((hashv) & ((num_bkts) - 1))
120
/* Fibonacci bucket determination.
121
 * Since we grow bucket sizes in multiples of two, we just need a right
122
 * bitmask to get it on the correct scale. This has an advantage over using &ing
123
 * or % to get the bucket number because it uses the full bit width of the hash.
124
 * If the size of the hashv is changed we will need to change max_hashv_div_phi,
125
 * to be max_hashv / phi rounded to the nearest *odd* number.
126
 * max_hashv / phi = 2654435769 */
127
const static uint32_t max_hashv_div_phi = 2654435769;
128
#define DETERMINE_BUCKET_FIB(hashv, offset) \
129
30.9M
    (((hashv) * max_hashv_div_phi) >> (32 - offset))
130
131
#define WHICH_BUCKET(hashv, num_bkts, offset)\
132
30.9M
    (DETERMINE_BUCKET_FIB((hashv), (offset)))
133
134
26.7M
#define HASH_FIND_VM_STR(tc,hh,head,key,out)                                        \
135
26.7M
do {                                                                                \
136
26.7M
  MVMhashv _hf_hashv;                                                               \
137
26.7M
  unsigned _hf_bkt;                                                                 \
138
26.7M
  out=NULL;                                                                         \
139
26.7M
  if (head) {                                                                       \
140
25.7M
     MVMhashv cached_hash = (key)->body.cached_hash_code;                           \
141
25.7M
     if (cached_hash) {                                                             \
142
25.0M
         _hf_hashv = cached_hash;                                                   \
143
25.0M
         _hf_bkt = WHICH_BUCKET((_hf_hashv), (head)->hh.tbl->num_buckets, (head)->hh.tbl->log2_num_buckets); \
144
25.0M
     }                                                                              \
145
794k
     else {                                                                         \
146
794k
         HASH_FCN_VM_STR(tc, key, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt, (head)->hh.tbl->log2_num_buckets); \
147
794k
     }                                                                              \
148
25.7M
     HASH_FIND_IN_BKT_VM_STR(tc, (head)->hh.tbl, hh,                                \
149
25.7M
         (head)->hh.tbl->buckets[ _hf_bkt ], key, out, _hf_hashv);                  \
150
25.7M
  }                                                                                 \
151
26.7M
} while (0)
152
MVM_PUBLIC MVM_NO_RETURN void MVM_exception_throw_adhoc(MVMThreadContext *tc, const char *messageFormat, ...) MVM_NO_RETURN_ATTRIBUTE MVM_FORMAT(printf, 2, 3);
153
634k
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
634k
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
634k
                  sizeof(UT_hash_table));
156
634k
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
634k
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
634k
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
634k
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
634k
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
634k
}
reprs.c:HASH_MAKE_TABLE
Line
Count
Source
153
144
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
144
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
144
                  sizeof(UT_hash_table));
156
144
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
144
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
144
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
144
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
144
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
144
}
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_MAKE_TABLE
Unexecuted instantiation: KnowHOWREPR.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMCFunction.c:HASH_MAKE_TABLE
MVMHash.c:HASH_MAKE_TABLE
Line
Count
Source
153
578k
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
578k
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
578k
                  sizeof(UT_hash_table));
156
578k
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
578k
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
578k
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
578k
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
578k
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
578k
}
Unexecuted instantiation: VMArray.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMString.c:HASH_MAKE_TABLE
Unexecuted instantiation: parametric.c:HASH_MAKE_TABLE
containers.c:HASH_MAKE_TABLE
Line
Count
Source
153
144
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
144
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
144
                  sizeof(UT_hash_table));
156
144
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
144
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
144
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
144
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
144
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
144
}
Unexecuted instantiation: reprconv.c:HASH_MAKE_TABLE
Unexecuted instantiation: P6str.c:HASH_MAKE_TABLE
Unexecuted instantiation: asyncsocketudp.c:HASH_MAKE_TABLE
Unexecuted instantiation: asyncsocket.c:HASH_MAKE_TABLE
Unexecuted instantiation: signals.c:HASH_MAKE_TABLE
Unexecuted instantiation: filewatchers.c:HASH_MAKE_TABLE
Unexecuted instantiation: timers.c:HASH_MAKE_TABLE
Unexecuted instantiation: procops.c:HASH_MAKE_TABLE
Unexecuted instantiation: dirops.c:HASH_MAKE_TABLE
Unexecuted instantiation: fileops.c:HASH_MAKE_TABLE
Unexecuted instantiation: syncsocket.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMThread.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMMultiCache.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMDLLSym.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMException.c:HASH_MAKE_TABLE
Unexecuted instantiation: NFA.c:HASH_MAKE_TABLE
Unexecuted instantiation: P6bigint.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMCallCapture.c:HASH_MAKE_TABLE
Unexecuted instantiation: SCRef.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMContext.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMIter.c:HASH_MAKE_TABLE
Unexecuted instantiation: syncfile.c:HASH_MAKE_TABLE
Unexecuted instantiation: HashAttrStore.c:HASH_MAKE_TABLE
Unexecuted instantiation: Uninstantiable.c:HASH_MAKE_TABLE
Unexecuted instantiation: P6num.c:HASH_MAKE_TABLE
Unexecuted instantiation: P6int.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMStaticFrame.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMCompUnit.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMOSHandle.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMCode.c:HASH_MAKE_TABLE
Unexecuted instantiation: P6opaque.c:HASH_MAKE_TABLE
Unexecuted instantiation: validation.c:HASH_MAKE_TABLE
Unexecuted instantiation: ext.c:HASH_MAKE_TABLE
Unexecuted instantiation: dll.c:HASH_MAKE_TABLE
Unexecuted instantiation: coerce.c:HASH_MAKE_TABLE
Unexecuted instantiation: num.c:HASH_MAKE_TABLE
loadbytecode.c:HASH_MAKE_TABLE
Line
Count
Source
153
144
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
144
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
144
                  sizeof(UT_hash_table));
156
144
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
144
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
144
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
144
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
144
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
144
}
hll.c:HASH_MAKE_TABLE
Line
Count
Source
153
144
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
144
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
144
                  sizeof(UT_hash_table));
156
144
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
144
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
144
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
144
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
144
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
144
}
Unexecuted instantiation: ops.c:HASH_MAKE_TABLE
Unexecuted instantiation: threads.c:HASH_MAKE_TABLE
Unexecuted instantiation: bytecodedump.c:HASH_MAKE_TABLE
Unexecuted instantiation: nativecall.c:HASH_MAKE_TABLE
Unexecuted instantiation: callstack.c:HASH_MAKE_TABLE
Unexecuted instantiation: frame.c:HASH_MAKE_TABLE
bytecode.c:HASH_MAKE_TABLE
Line
Count
Source
153
39.6k
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
39.6k
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
39.6k
                  sizeof(UT_hash_table));
156
39.6k
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
39.6k
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
39.6k
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
39.6k
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
39.6k
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
39.6k
}
Unexecuted instantiation: compunit.c:HASH_MAKE_TABLE
Unexecuted instantiation: threadcontext.c:HASH_MAKE_TABLE
Unexecuted instantiation: interp.c:HASH_MAKE_TABLE
Unexecuted instantiation: exceptions.c:HASH_MAKE_TABLE
Unexecuted instantiation: args.c:HASH_MAKE_TABLE
Unexecuted instantiation: callsite.c:HASH_MAKE_TABLE
Unexecuted instantiation: worklist.c:HASH_MAKE_TABLE
Unexecuted instantiation: eventloop.c:HASH_MAKE_TABLE
Unexecuted instantiation: io.c:HASH_MAKE_TABLE
Unexecuted instantiation: debug.c:HASH_MAKE_TABLE
Unexecuted instantiation: finalize.c:HASH_MAKE_TABLE
objectid.c:HASH_MAKE_TABLE
Line
Count
Source
153
158
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
158
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
158
                  sizeof(UT_hash_table));
156
158
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
158
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
158
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
158
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
158
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
158
}
Unexecuted instantiation: wb.c:HASH_MAKE_TABLE
Unexecuted instantiation: gen2.c:HASH_MAKE_TABLE
Unexecuted instantiation: collect.c:HASH_MAKE_TABLE
Unexecuted instantiation: roots.c:HASH_MAKE_TABLE
Unexecuted instantiation: arch.c:HASH_MAKE_TABLE
Unexecuted instantiation: allocation.c:HASH_MAKE_TABLE
Unexecuted instantiation: orchestrate.c:HASH_MAKE_TABLE
Unexecuted instantiation: config.c:HASH_MAKE_TABLE
Unexecuted instantiation: debugserver.c:HASH_MAKE_TABLE
Unexecuted instantiation: regionalloc.c:HASH_MAKE_TABLE
Unexecuted instantiation: fixedsizealloc.c:HASH_MAKE_TABLE
Unexecuted instantiation: intcache.c:HASH_MAKE_TABLE
Unexecuted instantiation: continuation.c:HASH_MAKE_TABLE
Unexecuted instantiation: nativecall_dyncall.c:HASH_MAKE_TABLE
Unexecuted instantiation: utf8_c8.c:HASH_MAKE_TABLE
Unexecuted instantiation: bigintops.c:HASH_MAKE_TABLE
Unexecuted instantiation: shiftjis_codeindex.c:HASH_MAKE_TABLE
Unexecuted instantiation: shiftjis.c:HASH_MAKE_TABLE
Unexecuted instantiation: windows1252.c:HASH_MAKE_TABLE
Unexecuted instantiation: utf16.c:HASH_MAKE_TABLE
Unexecuted instantiation: latin1.c:HASH_MAKE_TABLE
Unexecuted instantiation: normalize.c:HASH_MAKE_TABLE
unicode.c:HASH_MAKE_TABLE
Line
Count
Source
153
14.1k
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
14.1k
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
14.1k
                  sizeof(UT_hash_table));
156
14.1k
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
14.1k
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
14.1k
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
14.1k
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
14.1k
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
14.1k
}
Unexecuted instantiation: nfg.c:HASH_MAKE_TABLE
Unexecuted instantiation: instrument.c:HASH_MAKE_TABLE
Unexecuted instantiation: utf8.c:HASH_MAKE_TABLE
Unexecuted instantiation: parse_num.c:HASH_MAKE_TABLE
Unexecuted instantiation: ascii.c:HASH_MAKE_TABLE
Unexecuted instantiation: decode_stream.c:HASH_MAKE_TABLE
Unexecuted instantiation: plugin.c:HASH_MAKE_TABLE
Unexecuted instantiation: arg_guard.c:HASH_MAKE_TABLE
Unexecuted instantiation: plan.c:HASH_MAKE_TABLE
Unexecuted instantiation: stats.c:HASH_MAKE_TABLE
Unexecuted instantiation: worker.c:HASH_MAKE_TABLE
Unexecuted instantiation: mmap.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMContinuation.c:HASH_MAKE_TABLE
Unexecuted instantiation: emit.c:HASH_MAKE_TABLE
Unexecuted instantiation: interface.c:HASH_MAKE_TABLE
Unexecuted instantiation: linear_scan.c:HASH_MAKE_TABLE
Unexecuted instantiation: tile.c:HASH_MAKE_TABLE
Unexecuted instantiation: expr.c:HASH_MAKE_TABLE
Unexecuted instantiation: compile.c:HASH_MAKE_TABLE
Unexecuted instantiation: label.c:HASH_MAKE_TABLE
Unexecuted instantiation: time.c:HASH_MAKE_TABLE
Unexecuted instantiation: NativeCall.c:HASH_MAKE_TABLE
Unexecuted instantiation: moar.c:HASH_MAKE_TABLE
Unexecuted instantiation: memmem32.c:HASH_MAKE_TABLE
Unexecuted instantiation: random.c:HASH_MAKE_TABLE
Unexecuted instantiation: sys.c:HASH_MAKE_TABLE
Unexecuted instantiation: line_coverage.c:HASH_MAKE_TABLE
Unexecuted instantiation: crossthreadwrite.c:HASH_MAKE_TABLE
Unexecuted instantiation: telemeh.c:HASH_MAKE_TABLE
Unexecuted instantiation: heapsnapshot.c:HASH_MAKE_TABLE
Unexecuted instantiation: profile.c:HASH_MAKE_TABLE
Unexecuted instantiation: ConcBlockingQueue.c:HASH_MAKE_TABLE
Unexecuted instantiation: 6model.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMSpeshLog.c:HASH_MAKE_TABLE
Unexecuted instantiation: Decoder.c:HASH_MAKE_TABLE
Unexecuted instantiation: MultiDimArray.c:HASH_MAKE_TABLE
Unexecuted instantiation: NativeRef.c:HASH_MAKE_TABLE
Unexecuted instantiation: CPPStruct.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMNull.c:HASH_MAKE_TABLE
Unexecuted instantiation: MVMAsyncTask.c:HASH_MAKE_TABLE
Unexecuted instantiation: lookup.c:HASH_MAKE_TABLE
Unexecuted instantiation: Semaphore.c:HASH_MAKE_TABLE
Unexecuted instantiation: ConditionVariable.c:HASH_MAKE_TABLE
Unexecuted instantiation: ReentrantMutex.c:HASH_MAKE_TABLE
Unexecuted instantiation: CUnion.c:HASH_MAKE_TABLE
Unexecuted instantiation: CStruct.c:HASH_MAKE_TABLE
Unexecuted instantiation: CArray.c:HASH_MAKE_TABLE
Unexecuted instantiation: CStr.c:HASH_MAKE_TABLE
Unexecuted instantiation: CPointer.c:HASH_MAKE_TABLE
Unexecuted instantiation: iterator.c:HASH_MAKE_TABLE
sc.c:HASH_MAKE_TABLE
Line
Count
Source
153
144
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
144
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
144
                  sizeof(UT_hash_table));
156
144
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
144
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
144
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
144
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
144
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
144
}
Unexecuted instantiation: bootstrap.c:HASH_MAKE_TABLE
Unexecuted instantiation: osr.c:HASH_MAKE_TABLE
Unexecuted instantiation: inline.c:HASH_MAKE_TABLE
Unexecuted instantiation: threshold.c:HASH_MAKE_TABLE
Unexecuted instantiation: log.c:HASH_MAKE_TABLE
Unexecuted instantiation: deopt.c:HASH_MAKE_TABLE
Unexecuted instantiation: dead_bb_elimination.c:HASH_MAKE_TABLE
Unexecuted instantiation: optimize.c:HASH_MAKE_TABLE
Unexecuted instantiation: facts.c:HASH_MAKE_TABLE
Unexecuted instantiation: candidate.c:HASH_MAKE_TABLE
Unexecuted instantiation: codegen.c:HASH_MAKE_TABLE
Unexecuted instantiation: graph.c:HASH_MAKE_TABLE
Unexecuted instantiation: dump.c:HASH_MAKE_TABLE
Unexecuted instantiation: driver.c:HASH_MAKE_TABLE
compiler.c:HASH_MAKE_TABLE
Line
Count
Source
153
1.12k
MVM_STATIC_INLINE void HASH_MAKE_TABLE(MVMThreadContext *tc, void *head, UT_hash_handle *head_hh) {
154
1.12k
  head_hh->tbl = (UT_hash_table*)uthash_malloc_zeroed(tc,
155
1.12k
                  sizeof(UT_hash_table));
156
1.12k
  head_hh->tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;
157
1.12k
  head_hh->tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;
158
1.12k
  head_hh->tbl->hho = (char*)(head_hh) - (char*)(head);
159
1.12k
  head_hh->tbl->buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
160
1.12k
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));
161
1.12k
}
Unexecuted instantiation: serialization.c:HASH_MAKE_TABLE
Unexecuted instantiation: manipulate.c:HASH_MAKE_TABLE
162
163
797k
#define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add)                            \
164
797k
do {                                                                             \
165
797k
 unsigned _ha_bkt;                                                               \
166
797k
 (add)->hh.key = (char*)(keyptr);                                                \
167
797k
 (add)->hh.keylen = (unsigned)(keylen_in);                                       \
168
797k
 if (!(head)) {                                                                  \
169
15.4k
    head = (add);                                                                \
170
15.4k
    HASH_MAKE_TABLE(tc, head, &((head)->hh));                                                    \
171
15.4k
 }                                                                               \
172
797k
 (head)->hh.tbl->num_items++;                                                    \
173
797k
 (add)->hh.tbl = (head)->hh.tbl;                                                 \
174
797k
 HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets,                         \
175
797k
         (add)->hh.hashv, _ha_bkt, (head)->hh.tbl->log2_num_buckets);            \
176
797k
 HASH_ADD_TO_BKT(tc, &((head)->hh.tbl->buckets[_ha_bkt]),&(add)->hh);  \
177
797k
 HASH_FSCK(hh,head);                                                             \
178
797k
} while(0)
179
180
2.22M
#define HASH_ADD_KEYPTR_VM_STR(tc,hh,head,key_in,add)                            \
181
2.22M
do {                                                                             \
182
2.22M
 unsigned _ha_bkt;                                                               \
183
2.22M
 MVMhashv cached_hash = (key_in)->body.cached_hash_code;                         \
184
2.22M
 (add)->hh.key = (key_in);                                                       \
185
2.22M
 if (!(head)) {                                                                  \
186
619k
    head = (add);                                                                \
187
619k
    HASH_MAKE_TABLE(tc, head, &((head)->hh));                                    \
188
619k
 }                                                                               \
189
2.22M
 (head)->hh.tbl->num_items++;                                                    \
190
2.22M
 (add)->hh.tbl = (head)->hh.tbl;                                                 \
191
2.22M
 if (cached_hash) {                                                              \
192
2.10M
     (add)->hh.hashv = cached_hash;                                              \
193
2.10M
     _ha_bkt = WHICH_BUCKET((cached_hash),                                       \
194
2.10M
                  ((head)->hh.tbl->num_buckets),                                 \
195
2.10M
        (head)->hh.tbl->log2_num_buckets);                                       \
196
2.10M
 }                                                                               \
197
119k
 else {                                                                          \
198
119k
     HASH_FCN_VM_STR(tc, key_in, (head)->hh.tbl->num_buckets,                    \
199
119k
             (add)->hh.hashv, _ha_bkt, (head)->hh.tbl->log2_num_buckets);        \
200
119k
 }                                                                               \
201
2.22M
 HASH_ADD_TO_BKT(tc, &((head)->hh.tbl->buckets[_ha_bkt]),&(add)->hh);            \
202
2.22M
 HASH_FSCK(hh,head);                                                             \
203
2.22M
} while(0)
204
205
#define HASH_TO_BKT( hashv, num_bkts, bkt, offset )                              \
206
do {                                                                             \
207
  bkt = WHICH_BUCKET((hashv), (num_bkts), (offset));                             \
208
} while(0)
209
210
/* delete "delptr" from the hash table.
211
 * The use of _hd_hh_del below deserves special explanation.
212
 * These used to be expressed using (delptr) but that led to a bug
213
 * if someone used the same symbol for the head and deletee, like
214
 *  HASH_DELETE(hh,users,users);
215
 * We want that to work, but by changing the head (users) below
216
 * we were forfeiting our ability to further refer to the deletee (users)
217
 * in the patch-up process. Solution: use scratch space to
218
 * copy the deletee pointer, then the latter references are via that
219
 * scratch pointer rather than through the repointed (users) symbol.
220
 */
221
152k
#define HASH_DELETE(hh,head,delptr)                                              \
222
152k
do {                                                                             \
223
152k
    unsigned _hd_bkt;                                                            \
224
152k
    struct UT_hash_handle *_hd_hh_del;                                           \
225
152k
    if ( (head)->hh.tbl->num_items == 1 )  {                                     \
226
5.94k
        uthash_free(tc, (head)->hh.tbl->buckets,                                     \
227
5.94k
                    (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
228
5.94k
        uthash_free(tc, (head)->hh.tbl, sizeof(UT_hash_table));                      \
229
5.94k
        (head) = NULL;                                                           \
230
147k
    } else {                                                                     \
231
147k
        _hd_hh_del = &((delptr)->hh);                                            \
232
147k
        if ((delptr) == (head)) {                                                \
233
47.8k
            unsigned cur = 0;                                                    \
234
183k
            while (cur < (head)->hh.tbl->num_buckets) {                          \
235
183k
                UT_hash_handle *cand = (head)->hh.tbl->buckets[cur].hh_head;     \
236
206k
                while (cand) {                                                   \
237
70.9k
                    if (cand && cand != &((delptr)->hh)) {                       \
238
47.8k
                        DECLTYPE_ASSIGN((head), ELMT_FROM_HH((head)->hh.tbl,cand)); \
239
47.8k
                        goto REPLACED_HEAD;                                      \
240
47.8k
                    }                                                            \
241
23.1k
                    cand = cand->hh_next;                                        \
242
23.1k
                }                                                                \
243
135k
                cur++;                                                           \
244
135k
            }                                                                    \
245
0
            uthash_fatal("Failed to replace deleted head");                      \
246
47.8k
          REPLACED_HEAD: ;                                                       \
247
47.8k
        }                                                                        \
248
147k
        _hd_bkt = WHICH_BUCKET( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, (head)->hh.tbl->log2_num_buckets);   \
249
147k
        HASH_DEL_IN_BKT(&((head)->hh.tbl->buckets[_hd_bkt]), _hd_hh_del);        \
250
147k
        (head)->hh.tbl->num_items--;                                             \
251
147k
    }                                                                            \
252
152k
    HASH_FSCK(hh,head);                                                          \
253
152k
} while (0)
254
255
/* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
256
 * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
257
 */
258
#ifdef HASH_DEBUG
259
#define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
260
#define HASH_FSCK(hh,head)                                                       \
261
do {                                                                             \
262
    unsigned _bkt_i;                                                             \
263
    unsigned _count, _bkt_count;                                                 \
264
    char *_prev;                                                                 \
265
    struct UT_hash_handle *_thh;                                                 \
266
    if (head) {                                                                  \
267
        _count = 0;                                                              \
268
        for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) {       \
269
            _bkt_count = 0;                                                      \
270
            _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head;                      \
271
            _prev = NULL;                                                        \
272
            while (_thh) {                                                       \
273
               if (_prev != (char*)(_thh->hh_prev)) {                            \
274
                   HASH_OOPS("invalid hh_prev %p, actual %p\n",                  \
275
                    _thh->hh_prev, _prev );                                      \
276
               }                                                                 \
277
               _bkt_count++;                                                     \
278
               _prev = (char*)(_thh);                                            \
279
               _thh = _thh->hh_next;                                             \
280
            }                                                                    \
281
            _count += _bkt_count;                                                \
282
            if ((head)->hh.tbl->buckets[_bkt_i].count !=  _bkt_count) {          \
283
               HASH_OOPS("invalid bucket count %d, actual %d\n",                 \
284
                (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count);              \
285
            }                                                                    \
286
        }                                                                        \
287
        if (_count != (head)->hh.tbl->num_items) {                               \
288
            HASH_OOPS("invalid hh item count %d, actual %d\n",                   \
289
                (head)->hh.tbl->num_items, _count );                             \
290
        }                                                                        \
291
    }                                                                            \
292
} while (0)
293
#else
294
#define HASH_FSCK(hh,head)
295
#endif
296
297
/* Use Jenkin's hash as the hash function. */
298
815k
#define HASH_FCN HASH_JEN
299
914k
#define HASH_FCN_VM_STR HASH_JEN_VM_STR
300
301
4.99M
#define HASH_JEN_MIX(a,b,c)                                                      \
302
4.99M
do {                                                                             \
303
4.99M
  a -= b; a -= c; a ^= ( c >> 13 );                                              \
304
4.99M
  b -= c; b -= a; b ^= ( a << 8 );                                               \
305
4.99M
  c -= a; c -= b; c ^= ( b >> 13 );                                              \
306
4.99M
  a -= b; a -= c; a ^= ( c >> 12 );                                              \
307
4.99M
  b -= c; b -= a; b ^= ( a << 16 );                                              \
308
4.99M
  c -= a; c -= b; c ^= ( b >> 5 );                                               \
309
4.99M
  a -= b; a -= c; a ^= ( c >> 3 );                                               \
310
4.99M
  b -= c; b -= a; b ^= ( a << 10 );                                              \
311
4.99M
  c -= a; c -= b; c ^= ( b >> 15 );                                              \
312
4.99M
} while (0)
313
314
815k
#define HASH_JEN(key,keylen,num_bkts,hashv,bkt,offset)                           \
315
815k
do {                                                                             \
316
815k
  unsigned _hj_i,_hj_j,_hj_k;                                                    \
317
815k
  unsigned char *_hj_key=(unsigned char*)(key);                                  \
318
815k
  hashv = tc->instance->hashSecret;                                              \
319
815k
  _hj_i = _hj_j = 0x9e3779b9;                                                    \
320
815k
  _hj_k = (unsigned)(keylen);                                                    \
321
1.46M
  while (_hj_k >= 12) {                                                          \
322
648k
    _hj_i +=    (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 )                      \
323
648k
        + ( (unsigned)_hj_key[2] << 16 )                                         \
324
648k
        + ( (unsigned)_hj_key[3] << 24 ) );                                      \
325
648k
    _hj_j +=    (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 )                      \
326
648k
        + ( (unsigned)_hj_key[6] << 16 )                                         \
327
648k
        + ( (unsigned)_hj_key[7] << 24 ) );                                      \
328
648k
    hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 )                         \
329
648k
        + ( (unsigned)_hj_key[10] << 16 )                                        \
330
648k
        + ( (unsigned)_hj_key[11] << 24 ) );                                     \
331
648k
                                                                                 \
332
648k
     HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                          \
333
648k
                                                                                 \
334
648k
     _hj_key += 12;                                                              \
335
648k
     _hj_k -= 12;                                                                \
336
648k
  }                                                                              \
337
815k
  hashv += keylen;                                                               \
338
815k
  switch ( _hj_k ) {                                                             \
339
44.7k
     case 11: hashv += ( (unsigned)_hj_key[10] << 24 );                          \
340
102k
     case 10: hashv += ( (unsigned)_hj_key[9] << 16 );                           \
341
185k
     case 9:  hashv += ( (unsigned)_hj_key[8] << 8 );                            \
342
274k
     case 8:  _hj_j += ( (unsigned)_hj_key[7] << 24 );                           \
343
335k
     case 7:  _hj_j += ( (unsigned)_hj_key[6] << 16 );                           \
344
448k
     case 6:  _hj_j += ( (unsigned)_hj_key[5] << 8 );                            \
345
552k
     case 5:  _hj_j += _hj_key[4];                                               \
346
610k
     case 4:  _hj_i += ( (unsigned)_hj_key[3] << 24 );                           \
347
656k
     case 3:  _hj_i += ( (unsigned)_hj_key[2] << 16 );                           \
348
710k
     case 2:  _hj_i += ( (unsigned)_hj_key[1] << 8 );                            \
349
765k
     case 1:  _hj_i += _hj_key[0];                                               \
350
815k
  }                                                                              \
351
815k
  HASH_JEN_MIX(_hj_i, _hj_j, hashv);                                             \
352
815k
  if (hashv == 0) {                                                              \
353
0
      hashv += keylen;                                                           \
354
0
  }                                                                              \
355
815k
  bkt = WHICH_BUCKET(hashv, num_bkts, offset);                                   \
356
815k
} while(0)
357
358
914k
#define HASH_JEN_VM_STR(tc,key,num_bkts,hashv,bkt,offset)                        \
359
914k
do {                                                                             \
360
914k
  MVM_string_compute_hash_code(tc, key);                                         \
361
914k
  hashv = (key)->body.cached_hash_code;                                          \
362
914k
  bkt = WHICH_BUCKET((hashv), (num_bkts), offset);                               \
363
914k
} while(0)
364
365
/* key comparison function; return 0 if keys equal */
366
15.2k
#define HASH_KEYCMP(a,b,len) memcmp(a,b,len)
367
368
/* iterate over items in a known bucket to find desired item */
369
17.7k
#define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,out, hashval)              \
370
17.7k
do {                                                                             \
371
17.7k
 if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head));          \
372
1.73k
 else out=NULL;                                                                  \
373
25.6k
 while (out) {                                                                   \
374
23.1k
    if ((out)->hh.hashv == hashval && (out)->hh.keylen == keylen_in) {                                           \
375
15.2k
        if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break;             \
376
15.2k
    }                                                                            \
377
7.86k
    if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
378
747
    else out = NULL;                                                             \
379
7.86k
 }                                                                               \
380
17.7k
} while(0)
381
382
/* iterate over items in a known bucket to find desired item */
383
25.7M
#define HASH_FIND_IN_BKT_VM_STR(tc,tbl,hh,head,key_in,out,hashval)               \
384
25.7M
do {                                                                             \
385
25.7M
 if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head));          \
386
2.51M
 else out=NULL;                                                                  \
387
64.9M
 while (out) {                                                                   \
388
59.8M
    if (hashval == (out)->hh.hashv && MVM_string_equal(tc, (key_in), (MVMString *)((out)->hh.key)))            \
389
20.7M
        break;                                                                   \
390
39.1M
    if ((out)->hh.hh_next)                                                       \
391
36.5M
        DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next));                \
392
39.1M
    else                                                                         \
393
2.52M
        out = NULL;                                                              \
394
39.1M
 }                                                                               \
395
25.7M
} while(0)
396
397
/* Bucket expansion has the effect of doubling the number of buckets
398
 * and redistributing the items into the new buckets. Ideally the
399
 * items will distribute more or less evenly into the new buckets
400
 * (the extent to which this is true is a measure of the quality of
401
 * the hash function as it applies to the key domain).
402
 *
403
 * With the items distributed into more buckets, the chain length
404
 * (item count) in each bucket is reduced. Thus by expanding buckets
405
 * the hash keeps a bound on the chain length. This bounded chain
406
 * length is the essence of how a hash provides constant time lookup.
407
 *
408
 * The calculation of tbl->ideal_chain_maxlen below deserves some
409
 * explanation. First, keep in mind that we're calculating the ideal
410
 * maximum chain length based on the *new* (doubled) bucket count.
411
 * In fractions this is just n/b (n=number of items,b=new num buckets).
412
 * Since the ideal chain length is an integer, we want to calculate
413
 * ceil(n/b). We don't depend on floating point arithmetic in this
414
 * hash, so to calculate ceil(n/b) with integers we could write
415
 *
416
 *      ceil(n/b) = (n/b) + ((n%b)?1:0)
417
 *
418
 * and in fact a previous version of this hash did just that.
419
 * But now we have improved things a bit by recognizing that b is
420
 * always a power of two. We keep its base 2 log handy (call it lb),
421
 * so now we can write this with a bit shift and logical AND:
422
 *
423
 *      ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
424
 *
425
 */
426
11.9k
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
11.9k
    unsigned _he_bkt;
428
11.9k
    unsigned _he_bkt_i;
429
11.9k
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
11.9k
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
11.9k
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
11.9k
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
11.9k
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
11.9k
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
11.9k
    tbl->ideal_chain_maxlen =
436
11.9k
       (tbl->num_items >> new_log2_num_buckets) +
437
11.4k
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
11.9k
    tbl->nonideal_items = 0;
439
11.9k
    /* Iterate the buckets */
440
744k
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
732k
    {
442
732k
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
732k
        /* Iterate items in the bucket */
444
2.73M
        while (_he_thh) {
445
1.99M
           _he_hh_nxt = _he_thh->hh_next;
446
1.99M
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
1.99M
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
1.99M
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
342k
             tbl->nonideal_items++;
450
342k
             _he_newbkt->expand_mult = _he_newbkt->count /
451
342k
                                        tbl->ideal_chain_maxlen;
452
342k
           }
453
1.99M
           _he_thh->hh_prev = NULL;
454
1.99M
           _he_thh->hh_next = _he_newbkt->hh_head;
455
1.99M
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
1.18M
                _he_thh;
457
1.99M
           _he_newbkt->hh_head = _he_thh;
458
1.99M
           _he_thh = _he_hh_nxt;
459
1.99M
        }
460
732k
    }
461
11.9k
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
11.9k
    tbl->num_buckets = new_num_bkts;
463
11.9k
    tbl->log2_num_buckets = new_log2_num_buckets;
464
11.9k
    tbl->buckets = _he_new_buckets;
465
11.9k
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
11.8k
        (tbl->ineff_expands+1) : 0;
467
11.9k
    if (tbl->ineff_expands > 1) {
468
5
        tbl->noexpand=1;
469
5
        uthash_noexpand_fyi(tbl);
470
5
    }
471
11.9k
    uthash_expand_fyi(tbl);
472
11.9k
}
Unexecuted instantiation: manipulate.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: candidate.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: codegen.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: graph.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: dump.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: driver.c:HASH_EXPAND_BUCKETS
compiler.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
1
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
1
    unsigned _he_bkt;
428
1
    unsigned _he_bkt_i;
429
1
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
1
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
1
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
1
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
1
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
1
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
1
    tbl->ideal_chain_maxlen =
436
1
       (tbl->num_items >> new_log2_num_buckets) +
437
1
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
1
    tbl->nonideal_items = 0;
439
1
    /* Iterate the buckets */
440
9
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
8
    {
442
8
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
8
        /* Iterate items in the bucket */
444
58
        while (_he_thh) {
445
50
           _he_hh_nxt = _he_thh->hh_next;
446
50
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
50
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
50
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
7
             tbl->nonideal_items++;
450
7
             _he_newbkt->expand_mult = _he_newbkt->count /
451
7
                                        tbl->ideal_chain_maxlen;
452
7
           }
453
50
           _he_thh->hh_prev = NULL;
454
50
           _he_thh->hh_next = _he_newbkt->hh_head;
455
50
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
36
                _he_thh;
457
50
           _he_newbkt->hh_head = _he_thh;
458
50
           _he_thh = _he_hh_nxt;
459
50
        }
460
8
    }
461
1
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
1
    tbl->num_buckets = new_num_bkts;
463
1
    tbl->log2_num_buckets = new_log2_num_buckets;
464
1
    tbl->buckets = _he_new_buckets;
465
1
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
1
        (tbl->ineff_expands+1) : 0;
467
1
    if (tbl->ineff_expands > 1) {
468
0
        tbl->noexpand=1;
469
0
        uthash_noexpand_fyi(tbl);
470
0
    }
471
1
    uthash_expand_fyi(tbl);
472
1
}
Unexecuted instantiation: serialization.c:HASH_EXPAND_BUCKETS
sc.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
9
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
9
    unsigned _he_bkt;
428
9
    unsigned _he_bkt_i;
429
9
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
9
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
9
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
9
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
9
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
9
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
9
    tbl->ideal_chain_maxlen =
436
9
       (tbl->num_items >> new_log2_num_buckets) +
437
9
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
9
    tbl->nonideal_items = 0;
439
9
    /* Iterate the buckets */
440
305
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
296
    {
442
296
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
296
        /* Iterate items in the bucket */
444
2.13k
        while (_he_thh) {
445
1.84k
           _he_hh_nxt = _he_thh->hh_next;
446
1.84k
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
1.84k
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
1.84k
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
302
             tbl->nonideal_items++;
450
302
             _he_newbkt->expand_mult = _he_newbkt->count /
451
302
                                        tbl->ideal_chain_maxlen;
452
302
           }
453
1.84k
           _he_thh->hh_prev = NULL;
454
1.84k
           _he_thh->hh_next = _he_newbkt->hh_head;
455
1.84k
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
1.28k
                _he_thh;
457
1.84k
           _he_newbkt->hh_head = _he_thh;
458
1.84k
           _he_thh = _he_hh_nxt;
459
1.84k
        }
460
296
    }
461
9
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
9
    tbl->num_buckets = new_num_bkts;
463
9
    tbl->log2_num_buckets = new_log2_num_buckets;
464
9
    tbl->buckets = _he_new_buckets;
465
9
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
9
        (tbl->ineff_expands+1) : 0;
467
9
    if (tbl->ineff_expands > 1) {
468
0
        tbl->noexpand=1;
469
0
        uthash_noexpand_fyi(tbl);
470
0
    }
471
9
    uthash_expand_fyi(tbl);
472
9
}
Unexecuted instantiation: facts.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: optimize.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: dead_bb_elimination.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: deopt.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: log.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: threshold.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: inline.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: osr.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: lookup.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: iterator.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ConcBlockingQueue.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: NativeCall.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CPointer.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CStr.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CArray.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CStruct.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CUnion.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ReentrantMutex.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ConditionVariable.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: Semaphore.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: bootstrap.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMAsyncTask.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMNull.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: CPPStruct.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: NativeRef.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MultiDimArray.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: Decoder.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMSpeshLog.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: 6model.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: time.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: heapsnapshot.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: telemeh.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: crossthreadwrite.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: line_coverage.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: sys.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: random.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: memmem32.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: moar.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: mmap.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: profile.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: label.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: compile.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: expr.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: tile.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: linear_scan.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: interface.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: emit.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: arch.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: syncfile.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: nfg.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: stats.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: plan.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: arg_guard.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: plugin.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: decode_stream.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ascii.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: parse_num.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: utf8.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: utf8_c8.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: worker.c:HASH_EXPAND_BUCKETS
unicode.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
4.06k
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
4.06k
    unsigned _he_bkt;
428
4.06k
    unsigned _he_bkt_i;
429
4.06k
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
4.06k
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
4.06k
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
4.06k
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
4.06k
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
4.06k
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
4.06k
    tbl->ideal_chain_maxlen =
436
4.06k
       (tbl->num_items >> new_log2_num_buckets) +
437
3.91k
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
4.06k
    tbl->nonideal_items = 0;
439
4.06k
    /* Iterate the buckets */
440
585k
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
581k
    {
442
581k
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
581k
        /* Iterate items in the bucket */
444
1.70M
        while (_he_thh) {
445
1.12M
           _he_hh_nxt = _he_thh->hh_next;
446
1.12M
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
1.12M
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
1.12M
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
199k
             tbl->nonideal_items++;
450
199k
             _he_newbkt->expand_mult = _he_newbkt->count /
451
199k
                                        tbl->ideal_chain_maxlen;
452
199k
           }
453
1.12M
           _he_thh->hh_prev = NULL;
454
1.12M
           _he_thh->hh_next = _he_newbkt->hh_head;
455
1.12M
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
593k
                _he_thh;
457
1.12M
           _he_newbkt->hh_head = _he_thh;
458
1.12M
           _he_thh = _he_hh_nxt;
459
1.12M
        }
460
581k
    }
461
4.06k
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
4.06k
    tbl->num_buckets = new_num_bkts;
463
4.06k
    tbl->log2_num_buckets = new_log2_num_buckets;
464
4.06k
    tbl->buckets = _he_new_buckets;
465
4.06k
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
4.05k
        (tbl->ineff_expands+1) : 0;
467
4.06k
    if (tbl->ineff_expands > 1) {
468
0
        tbl->noexpand=1;
469
0
        uthash_noexpand_fyi(tbl);
470
0
    }
471
4.06k
    uthash_expand_fyi(tbl);
472
4.06k
}
Unexecuted instantiation: normalize.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: latin1.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: utf16.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: windows1252.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: shiftjis.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: shiftjis_codeindex.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: bigintops.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: instrument.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: worklist.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: nativecall_dyncall.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: continuation.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: intcache.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: fixedsizealloc.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: regionalloc.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: debugserver.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: config.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: orchestrate.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: allocation.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: nativecall.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: roots.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: collect.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: gen2.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: wb.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: objectid.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: finalize.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: debug.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: io.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: eventloop.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: validation.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: callsite.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: args.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: exceptions.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: interp.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: threadcontext.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: compunit.c:HASH_EXPAND_BUCKETS
bytecode.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
175
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
175
    unsigned _he_bkt;
428
175
    unsigned _he_bkt_i;
429
175
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
175
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
175
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
175
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
175
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
175
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
175
    tbl->ideal_chain_maxlen =
436
175
       (tbl->num_items >> new_log2_num_buckets) +
437
162
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
175
    tbl->nonideal_items = 0;
439
175
    /* Iterate the buckets */
440
1.57k
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
1.40k
    {
442
1.40k
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
1.40k
        /* Iterate items in the bucket */
444
9.29k
        while (_he_thh) {
445
7.89k
           _he_hh_nxt = _he_thh->hh_next;
446
7.89k
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
7.89k
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
7.89k
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
1.31k
             tbl->nonideal_items++;
450
1.31k
             _he_newbkt->expand_mult = _he_newbkt->count /
451
1.31k
                                        tbl->ideal_chain_maxlen;
452
1.31k
           }
453
7.89k
           _he_thh->hh_prev = NULL;
454
7.89k
           _he_thh->hh_next = _he_newbkt->hh_head;
455
7.89k
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
5.28k
                _he_thh;
457
7.89k
           _he_newbkt->hh_head = _he_thh;
458
7.89k
           _he_thh = _he_hh_nxt;
459
7.89k
        }
460
1.40k
    }
461
175
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
175
    tbl->num_buckets = new_num_bkts;
463
175
    tbl->log2_num_buckets = new_log2_num_buckets;
464
175
    tbl->buckets = _he_new_buckets;
465
175
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
175
        (tbl->ineff_expands+1) : 0;
467
175
    if (tbl->ineff_expands > 1) {
468
0
        tbl->noexpand=1;
469
0
        uthash_noexpand_fyi(tbl);
470
0
    }
471
175
    uthash_expand_fyi(tbl);
472
175
}
Unexecuted instantiation: frame.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: callstack.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMMultiCache.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: bytecodedump.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: threads.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ops.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: hll.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: loadbytecode.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: num.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: coerce.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: dll.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: ext.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMThread.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: P6opaque.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMCode.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMOSHandle.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMCompUnit.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMStaticFrame.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: P6int.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: P6num.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: Uninstantiable.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: HashAttrStore.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: syncsocket.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMIter.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMContext.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: SCRef.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMCallCapture.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: P6bigint.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: NFA.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMException.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMDLLSym.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMContinuation.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: P6str.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: fileops.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: dirops.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: procops.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: timers.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: filewatchers.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: signals.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: asyncsocket.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: asyncsocketudp.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: reprconv.c:HASH_EXPAND_BUCKETS
reprs.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
48
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
48
    unsigned _he_bkt;
428
48
    unsigned _he_bkt_i;
429
48
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
48
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
48
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
48
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
48
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
48
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
48
    tbl->ideal_chain_maxlen =
436
48
       (tbl->num_items >> new_log2_num_buckets) +
437
46
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
48
    tbl->nonideal_items = 0;
439
48
    /* Iterate the buckets */
440
432
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
384
    {
442
384
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
384
        /* Iterate items in the bucket */
444
2.20k
        while (_he_thh) {
445
1.82k
           _he_hh_nxt = _he_thh->hh_next;
446
1.82k
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
1.82k
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
1.82k
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
358
             tbl->nonideal_items++;
450
358
             _he_newbkt->expand_mult = _he_newbkt->count /
451
358
                                        tbl->ideal_chain_maxlen;
452
358
           }
453
1.82k
           _he_thh->hh_prev = NULL;
454
1.82k
           _he_thh->hh_next = _he_newbkt->hh_head;
455
1.82k
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
1.15k
                _he_thh;
457
1.82k
           _he_newbkt->hh_head = _he_thh;
458
1.82k
           _he_thh = _he_hh_nxt;
459
1.82k
        }
460
384
    }
461
48
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
48
    tbl->num_buckets = new_num_bkts;
463
48
    tbl->log2_num_buckets = new_log2_num_buckets;
464
48
    tbl->buckets = _he_new_buckets;
465
48
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
48
        (tbl->ineff_expands+1) : 0;
467
48
    if (tbl->ineff_expands > 1) {
468
0
        tbl->noexpand=1;
469
0
        uthash_noexpand_fyi(tbl);
470
0
    }
471
48
    uthash_expand_fyi(tbl);
472
48
}
Unexecuted instantiation: KnowHOWREPR.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMCFunction.c:HASH_EXPAND_BUCKETS
MVMHash.c:HASH_EXPAND_BUCKETS
Line
Count
Source
426
7.67k
MVM_STATIC_INLINE void HASH_EXPAND_BUCKETS(MVMThreadContext *tc, UT_hash_table *tbl) {
427
7.67k
    unsigned _he_bkt;
428
7.67k
    unsigned _he_bkt_i;
429
7.67k
    struct UT_hash_handle *_he_thh, *_he_hh_nxt;
430
7.67k
    UT_hash_bucket *_he_new_buckets, *_he_newbkt;
431
7.67k
    unsigned new_num_bkts = tbl->num_buckets * 2;
432
7.67k
    unsigned new_log2_num_buckets = tbl->log2_num_buckets + 1;
433
7.67k
    _he_new_buckets = (UT_hash_bucket*)uthash_malloc_zeroed(tc,
434
7.67k
             new_num_bkts * sizeof(struct UT_hash_bucket));
435
7.67k
    tbl->ideal_chain_maxlen =
436
7.67k
       (tbl->num_items >> new_log2_num_buckets) +
437
7.32k
       ((tbl->num_items & (new_num_bkts-1)) ? 1 : 0);
438
7.67k
    tbl->nonideal_items = 0;
439
7.67k
    /* Iterate the buckets */
440
156k
    for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++)
441
148k
    {
442
148k
        _he_thh = tbl->buckets[ _he_bkt_i ].hh_head;
443
148k
        /* Iterate items in the bucket */
444
1.01M
        while (_he_thh) {
445
864k
           _he_hh_nxt = _he_thh->hh_next;
446
864k
           _he_bkt = WHICH_BUCKET( _he_thh->hashv, new_num_bkts, new_log2_num_buckets);
447
864k
           _he_newbkt = &(_he_new_buckets[ _he_bkt ]);
448
864k
           if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) {
449
140k
             tbl->nonideal_items++;
450
140k
             _he_newbkt->expand_mult = _he_newbkt->count /
451
140k
                                        tbl->ideal_chain_maxlen;
452
140k
           }
453
864k
           _he_thh->hh_prev = NULL;
454
864k
           _he_thh->hh_next = _he_newbkt->hh_head;
455
864k
           if (_he_newbkt->hh_head) _he_newbkt->hh_head->hh_prev =
456
586k
                _he_thh;
457
864k
           _he_newbkt->hh_head = _he_thh;
458
864k
           _he_thh = _he_hh_nxt;
459
864k
        }
460
148k
    }
461
7.67k
    uthash_free(tc, tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) );
462
7.67k
    tbl->num_buckets = new_num_bkts;
463
7.67k
    tbl->log2_num_buckets = new_log2_num_buckets;
464
7.67k
    tbl->buckets = _he_new_buckets;
465
7.67k
    tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ?
466
7.55k
        (tbl->ineff_expands+1) : 0;
467
7.67k
    if (tbl->ineff_expands > 1) {
468
5
        tbl->noexpand=1;
469
5
        uthash_noexpand_fyi(tbl);
470
5
    }
471
7.67k
    uthash_expand_fyi(tbl);
472
7.67k
}
Unexecuted instantiation: VMArray.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: MVMString.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: parametric.c:HASH_EXPAND_BUCKETS
Unexecuted instantiation: containers.c:HASH_EXPAND_BUCKETS
473
474
/* add an item to a bucket  */
475
3.02M
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
3.02M
 head->count++;
477
3.02M
 addhh->hh_next = head->hh_head;
478
3.02M
 addhh->hh_prev = NULL;
479
3.02M
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
3.02M
 head->hh_head = addhh;
481
3.02M
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
11.9k
     && addhh->tbl->noexpand != 1) {
483
11.9k
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
11.9k
 }
485
3.02M
}
Unexecuted instantiation: bootstrap.c:HASH_ADD_TO_BKT
sc.c:HASH_ADD_TO_BKT
Line
Count
Source
475
1.47k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
1.47k
 head->count++;
477
1.47k
 addhh->hh_next = head->hh_head;
478
1.47k
 addhh->hh_prev = NULL;
479
1.47k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
1.47k
 head->hh_head = addhh;
481
1.47k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
9
     && addhh->tbl->noexpand != 1) {
483
9
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
9
 }
485
1.47k
}
Unexecuted instantiation: serialization.c:HASH_ADD_TO_BKT
compiler.c:HASH_ADD_TO_BKT
Line
Count
Source
475
3.59k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
3.59k
 head->count++;
477
3.59k
 addhh->hh_next = head->hh_head;
478
3.59k
 addhh->hh_prev = NULL;
479
3.59k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
3.59k
 head->hh_head = addhh;
481
3.59k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
1
     && addhh->tbl->noexpand != 1) {
483
1
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
1
 }
485
3.59k
}
Unexecuted instantiation: driver.c:HASH_ADD_TO_BKT
Unexecuted instantiation: dump.c:HASH_ADD_TO_BKT
Unexecuted instantiation: graph.c:HASH_ADD_TO_BKT
Unexecuted instantiation: codegen.c:HASH_ADD_TO_BKT
Unexecuted instantiation: candidate.c:HASH_ADD_TO_BKT
Unexecuted instantiation: manipulate.c:HASH_ADD_TO_BKT
Unexecuted instantiation: facts.c:HASH_ADD_TO_BKT
Unexecuted instantiation: optimize.c:HASH_ADD_TO_BKT
Unexecuted instantiation: dead_bb_elimination.c:HASH_ADD_TO_BKT
Unexecuted instantiation: deopt.c:HASH_ADD_TO_BKT
Unexecuted instantiation: log.c:HASH_ADD_TO_BKT
Unexecuted instantiation: threshold.c:HASH_ADD_TO_BKT
Unexecuted instantiation: inline.c:HASH_ADD_TO_BKT
Unexecuted instantiation: osr.c:HASH_ADD_TO_BKT
Unexecuted instantiation: lookup.c:HASH_ADD_TO_BKT
Unexecuted instantiation: iterator.c:HASH_ADD_TO_BKT
Unexecuted instantiation: Semaphore.c:HASH_ADD_TO_BKT
Unexecuted instantiation: NativeCall.c:HASH_ADD_TO_BKT
Unexecuted instantiation: callsite.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CPointer.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CStr.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CArray.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CStruct.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CUnion.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ReentrantMutex.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ConditionVariable.c:HASH_ADD_TO_BKT
Unexecuted instantiation: 6model.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ConcBlockingQueue.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMAsyncTask.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMNull.c:HASH_ADD_TO_BKT
Unexecuted instantiation: CPPStruct.c:HASH_ADD_TO_BKT
Unexecuted instantiation: NativeRef.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MultiDimArray.c:HASH_ADD_TO_BKT
Unexecuted instantiation: Decoder.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMSpeshLog.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_ADD_TO_BKT
Unexecuted instantiation: mmap.c:HASH_ADD_TO_BKT
Unexecuted instantiation: profile.c:HASH_ADD_TO_BKT
Unexecuted instantiation: heapsnapshot.c:HASH_ADD_TO_BKT
Unexecuted instantiation: telemeh.c:HASH_ADD_TO_BKT
Unexecuted instantiation: crossthreadwrite.c:HASH_ADD_TO_BKT
Unexecuted instantiation: line_coverage.c:HASH_ADD_TO_BKT
Unexecuted instantiation: sys.c:HASH_ADD_TO_BKT
Unexecuted instantiation: random.c:HASH_ADD_TO_BKT
Unexecuted instantiation: memmem32.c:HASH_ADD_TO_BKT
Unexecuted instantiation: moar.c:HASH_ADD_TO_BKT
Unexecuted instantiation: instrument.c:HASH_ADD_TO_BKT
Unexecuted instantiation: time.c:HASH_ADD_TO_BKT
Unexecuted instantiation: label.c:HASH_ADD_TO_BKT
Unexecuted instantiation: compile.c:HASH_ADD_TO_BKT
Unexecuted instantiation: expr.c:HASH_ADD_TO_BKT
Unexecuted instantiation: tile.c:HASH_ADD_TO_BKT
Unexecuted instantiation: linear_scan.c:HASH_ADD_TO_BKT
Unexecuted instantiation: interface.c:HASH_ADD_TO_BKT
Unexecuted instantiation: emit.c:HASH_ADD_TO_BKT
Unexecuted instantiation: arch.c:HASH_ADD_TO_BKT
Unexecuted instantiation: nfg.c:HASH_ADD_TO_BKT
Unexecuted instantiation: stats.c:HASH_ADD_TO_BKT
Unexecuted instantiation: plan.c:HASH_ADD_TO_BKT
Unexecuted instantiation: arg_guard.c:HASH_ADD_TO_BKT
Unexecuted instantiation: plugin.c:HASH_ADD_TO_BKT
Unexecuted instantiation: decode_stream.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ascii.c:HASH_ADD_TO_BKT
Unexecuted instantiation: parse_num.c:HASH_ADD_TO_BKT
Unexecuted instantiation: utf8.c:HASH_ADD_TO_BKT
Unexecuted instantiation: utf8_c8.c:HASH_ADD_TO_BKT
Unexecuted instantiation: worker.c:HASH_ADD_TO_BKT
unicode.c:HASH_ADD_TO_BKT
Line
Count
Source
475
793k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
793k
 head->count++;
477
793k
 addhh->hh_next = head->hh_head;
478
793k
 addhh->hh_prev = NULL;
479
793k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
793k
 head->hh_head = addhh;
481
793k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
4.06k
     && addhh->tbl->noexpand != 1) {
483
4.06k
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
4.06k
 }
485
793k
}
Unexecuted instantiation: normalize.c:HASH_ADD_TO_BKT
Unexecuted instantiation: latin1.c:HASH_ADD_TO_BKT
Unexecuted instantiation: utf16.c:HASH_ADD_TO_BKT
Unexecuted instantiation: windows1252.c:HASH_ADD_TO_BKT
Unexecuted instantiation: shiftjis.c:HASH_ADD_TO_BKT
Unexecuted instantiation: shiftjis_codeindex.c:HASH_ADD_TO_BKT
Unexecuted instantiation: bigintops.c:HASH_ADD_TO_BKT
Unexecuted instantiation: worklist.c:HASH_ADD_TO_BKT
Unexecuted instantiation: nativecall_dyncall.c:HASH_ADD_TO_BKT
Unexecuted instantiation: continuation.c:HASH_ADD_TO_BKT
Unexecuted instantiation: intcache.c:HASH_ADD_TO_BKT
Unexecuted instantiation: fixedsizealloc.c:HASH_ADD_TO_BKT
Unexecuted instantiation: regionalloc.c:HASH_ADD_TO_BKT
Unexecuted instantiation: debugserver.c:HASH_ADD_TO_BKT
Unexecuted instantiation: config.c:HASH_ADD_TO_BKT
Unexecuted instantiation: orchestrate.c:HASH_ADD_TO_BKT
Unexecuted instantiation: allocation.c:HASH_ADD_TO_BKT
Unexecuted instantiation: nativecall.c:HASH_ADD_TO_BKT
Unexecuted instantiation: roots.c:HASH_ADD_TO_BKT
Unexecuted instantiation: collect.c:HASH_ADD_TO_BKT
Unexecuted instantiation: gen2.c:HASH_ADD_TO_BKT
Unexecuted instantiation: wb.c:HASH_ADD_TO_BKT
objectid.c:HASH_ADD_TO_BKT
Line
Count
Source
475
349
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
349
 head->count++;
477
349
 addhh->hh_next = head->hh_head;
478
349
 addhh->hh_prev = NULL;
479
349
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
349
 head->hh_head = addhh;
481
349
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
0
     && addhh->tbl->noexpand != 1) {
483
0
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
0
 }
485
349
}
Unexecuted instantiation: finalize.c:HASH_ADD_TO_BKT
Unexecuted instantiation: debug.c:HASH_ADD_TO_BKT
Unexecuted instantiation: io.c:HASH_ADD_TO_BKT
Unexecuted instantiation: eventloop.c:HASH_ADD_TO_BKT
Unexecuted instantiation: validation.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMContinuation.c:HASH_ADD_TO_BKT
Unexecuted instantiation: args.c:HASH_ADD_TO_BKT
Unexecuted instantiation: exceptions.c:HASH_ADD_TO_BKT
Unexecuted instantiation: interp.c:HASH_ADD_TO_BKT
Unexecuted instantiation: threadcontext.c:HASH_ADD_TO_BKT
Unexecuted instantiation: compunit.c:HASH_ADD_TO_BKT
bytecode.c:HASH_ADD_TO_BKT
Line
Count
Source
475
132k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
132k
 head->count++;
477
132k
 addhh->hh_next = head->hh_head;
478
132k
 addhh->hh_prev = NULL;
479
132k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
132k
 head->hh_head = addhh;
481
132k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
175
     && addhh->tbl->noexpand != 1) {
483
175
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
175
 }
485
132k
}
Unexecuted instantiation: frame.c:HASH_ADD_TO_BKT
Unexecuted instantiation: callstack.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMMultiCache.c:HASH_ADD_TO_BKT
Unexecuted instantiation: bytecodedump.c:HASH_ADD_TO_BKT
Unexecuted instantiation: threads.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ops.c:HASH_ADD_TO_BKT
hll.c:HASH_ADD_TO_BKT
Line
Count
Source
475
164
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
164
 head->count++;
477
164
 addhh->hh_next = head->hh_head;
478
164
 addhh->hh_prev = NULL;
479
164
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
164
 head->hh_head = addhh;
481
164
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
0
     && addhh->tbl->noexpand != 1) {
483
0
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
0
 }
485
164
}
loadbytecode.c:HASH_ADD_TO_BKT
Line
Count
Source
475
1.44k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
1.44k
 head->count++;
477
1.44k
 addhh->hh_next = head->hh_head;
478
1.44k
 addhh->hh_prev = NULL;
479
1.44k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
1.44k
 head->hh_head = addhh;
481
1.44k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
0
     && addhh->tbl->noexpand != 1) {
483
0
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
0
 }
485
1.44k
}
Unexecuted instantiation: num.c:HASH_ADD_TO_BKT
Unexecuted instantiation: coerce.c:HASH_ADD_TO_BKT
Unexecuted instantiation: dll.c:HASH_ADD_TO_BKT
Unexecuted instantiation: ext.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMThread.c:HASH_ADD_TO_BKT
Unexecuted instantiation: P6opaque.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMCode.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMOSHandle.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMCompUnit.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMStaticFrame.c:HASH_ADD_TO_BKT
Unexecuted instantiation: P6int.c:HASH_ADD_TO_BKT
Unexecuted instantiation: P6num.c:HASH_ADD_TO_BKT
Unexecuted instantiation: Uninstantiable.c:HASH_ADD_TO_BKT
Unexecuted instantiation: HashAttrStore.c:HASH_ADD_TO_BKT
Unexecuted instantiation: syncsocket.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMIter.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMContext.c:HASH_ADD_TO_BKT
Unexecuted instantiation: SCRef.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMCallCapture.c:HASH_ADD_TO_BKT
Unexecuted instantiation: P6bigint.c:HASH_ADD_TO_BKT
Unexecuted instantiation: NFA.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMException.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMDLLSym.c:HASH_ADD_TO_BKT
Unexecuted instantiation: syncfile.c:HASH_ADD_TO_BKT
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_ADD_TO_BKT
Unexecuted instantiation: P6str.c:HASH_ADD_TO_BKT
Unexecuted instantiation: fileops.c:HASH_ADD_TO_BKT
Unexecuted instantiation: dirops.c:HASH_ADD_TO_BKT
Unexecuted instantiation: procops.c:HASH_ADD_TO_BKT
Unexecuted instantiation: timers.c:HASH_ADD_TO_BKT
Unexecuted instantiation: filewatchers.c:HASH_ADD_TO_BKT
Unexecuted instantiation: signals.c:HASH_ADD_TO_BKT
Unexecuted instantiation: asyncsocket.c:HASH_ADD_TO_BKT
Unexecuted instantiation: asyncsocketudp.c:HASH_ADD_TO_BKT
Unexecuted instantiation: reprconv.c:HASH_ADD_TO_BKT
reprs.c:HASH_ADD_TO_BKT
Line
Count
Source
475
6.48k
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
6.48k
 head->count++;
477
6.48k
 addhh->hh_next = head->hh_head;
478
6.48k
 addhh->hh_prev = NULL;
479
6.48k
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
6.48k
 head->hh_head = addhh;
481
6.48k
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
48
     && addhh->tbl->noexpand != 1) {
483
48
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
48
 }
485
6.48k
}
Unexecuted instantiation: KnowHOWREPR.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMCFunction.c:HASH_ADD_TO_BKT
MVMHash.c:HASH_ADD_TO_BKT
Line
Count
Source
475
2.08M
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
2.08M
 head->count++;
477
2.08M
 addhh->hh_next = head->hh_head;
478
2.08M
 addhh->hh_prev = NULL;
479
2.08M
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
2.08M
 head->hh_head = addhh;
481
2.08M
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
7.67k
     && addhh->tbl->noexpand != 1) {
483
7.67k
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
7.67k
 }
485
2.08M
}
Unexecuted instantiation: VMArray.c:HASH_ADD_TO_BKT
Unexecuted instantiation: MVMString.c:HASH_ADD_TO_BKT
Unexecuted instantiation: parametric.c:HASH_ADD_TO_BKT
containers.c:HASH_ADD_TO_BKT
Line
Count
Source
475
288
MVM_STATIC_INLINE void HASH_ADD_TO_BKT(MVMThreadContext *tc, UT_hash_bucket *head, UT_hash_handle *addhh) {
476
288
 head->count++;
477
288
 addhh->hh_next = head->hh_head;
478
288
 addhh->hh_prev = NULL;
479
288
 if (head->hh_head) { head->hh_head->hh_prev = addhh; }
480
288
 head->hh_head = addhh;
481
288
 if (head->count >= ((head->expand_mult+1) * HASH_BKT_CAPACITY_THRESH)
482
0
     && addhh->tbl->noexpand != 1) {
483
0
        HASH_EXPAND_BUCKETS(tc, addhh->tbl);
484
0
 }
485
288
}
486
487
/* remove an item from a given bucket */
488
147k
MVM_STATIC_INLINE void HASH_DEL_IN_BKT(UT_hash_bucket *head, UT_hash_handle *hh_del) {
489
147k
    head->count--;
490
147k
    if (head->hh_head == hh_del) {
491
116k
      head->hh_head = hh_del->hh_next;
492
116k
    }
493
147k
    if (hh_del->hh_prev) {
494
30.0k
        hh_del->hh_prev->hh_next = hh_del->hh_next;
495
30.0k
    }
496
147k
    if (hh_del->hh_next) {
497
24.2k
        hh_del->hh_next->hh_prev = hh_del->hh_prev;
498
24.2k
    }
499
147k
}
Unexecuted instantiation: 6model.c:HASH_DEL_IN_BKT
Unexecuted instantiation: bootstrap.c:HASH_DEL_IN_BKT
Unexecuted instantiation: sc.c:HASH_DEL_IN_BKT
Unexecuted instantiation: serialization.c:HASH_DEL_IN_BKT
Unexecuted instantiation: compiler.c:HASH_DEL_IN_BKT
Unexecuted instantiation: driver.c:HASH_DEL_IN_BKT
Unexecuted instantiation: dump.c:HASH_DEL_IN_BKT
Unexecuted instantiation: graph.c:HASH_DEL_IN_BKT
Unexecuted instantiation: codegen.c:HASH_DEL_IN_BKT
Unexecuted instantiation: candidate.c:HASH_DEL_IN_BKT
Unexecuted instantiation: manipulate.c:HASH_DEL_IN_BKT
Unexecuted instantiation: facts.c:HASH_DEL_IN_BKT
Unexecuted instantiation: optimize.c:HASH_DEL_IN_BKT
Unexecuted instantiation: dead_bb_elimination.c:HASH_DEL_IN_BKT
Unexecuted instantiation: deopt.c:HASH_DEL_IN_BKT
Unexecuted instantiation: log.c:HASH_DEL_IN_BKT
Unexecuted instantiation: threshold.c:HASH_DEL_IN_BKT
Unexecuted instantiation: inline.c:HASH_DEL_IN_BKT
Unexecuted instantiation: osr.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ConditionVariable.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMMultiCache.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMContinuation.c:HASH_DEL_IN_BKT
Unexecuted instantiation: NativeCall.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CPointer.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CStr.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CArray.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CStruct.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CUnion.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ReentrantMutex.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_DEL_IN_BKT
Unexecuted instantiation: Semaphore.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ConcBlockingQueue.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMAsyncTask.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMNull.c:HASH_DEL_IN_BKT
Unexecuted instantiation: CPPStruct.c:HASH_DEL_IN_BKT
Unexecuted instantiation: NativeRef.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MultiDimArray.c:HASH_DEL_IN_BKT
Unexecuted instantiation: Decoder.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMSpeshLog.c:HASH_DEL_IN_BKT
Unexecuted instantiation: moar.c:HASH_DEL_IN_BKT
Unexecuted instantiation: instrument.c:HASH_DEL_IN_BKT
Unexecuted instantiation: profile.c:HASH_DEL_IN_BKT
Unexecuted instantiation: heapsnapshot.c:HASH_DEL_IN_BKT
Unexecuted instantiation: telemeh.c:HASH_DEL_IN_BKT
Unexecuted instantiation: crossthreadwrite.c:HASH_DEL_IN_BKT
Unexecuted instantiation: line_coverage.c:HASH_DEL_IN_BKT
Unexecuted instantiation: sys.c:HASH_DEL_IN_BKT
Unexecuted instantiation: random.c:HASH_DEL_IN_BKT
Unexecuted instantiation: memmem32.c:HASH_DEL_IN_BKT
Unexecuted instantiation: bigintops.c:HASH_DEL_IN_BKT
Unexecuted instantiation: mmap.c:HASH_DEL_IN_BKT
Unexecuted instantiation: time.c:HASH_DEL_IN_BKT
Unexecuted instantiation: label.c:HASH_DEL_IN_BKT
Unexecuted instantiation: compile.c:HASH_DEL_IN_BKT
Unexecuted instantiation: expr.c:HASH_DEL_IN_BKT
Unexecuted instantiation: tile.c:HASH_DEL_IN_BKT
Unexecuted instantiation: linear_scan.c:HASH_DEL_IN_BKT
Unexecuted instantiation: interface.c:HASH_DEL_IN_BKT
Unexecuted instantiation: emit.c:HASH_DEL_IN_BKT
Unexecuted instantiation: utf8.c:HASH_DEL_IN_BKT
Unexecuted instantiation: iterator.c:HASH_DEL_IN_BKT
Unexecuted instantiation: worker.c:HASH_DEL_IN_BKT
Unexecuted instantiation: stats.c:HASH_DEL_IN_BKT
Unexecuted instantiation: plan.c:HASH_DEL_IN_BKT
Unexecuted instantiation: arg_guard.c:HASH_DEL_IN_BKT
Unexecuted instantiation: plugin.c:HASH_DEL_IN_BKT
Unexecuted instantiation: decode_stream.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ascii.c:HASH_DEL_IN_BKT
Unexecuted instantiation: parse_num.c:HASH_DEL_IN_BKT
Unexecuted instantiation: lookup.c:HASH_DEL_IN_BKT
Unexecuted instantiation: utf8_c8.c:HASH_DEL_IN_BKT
Unexecuted instantiation: nfg.c:HASH_DEL_IN_BKT
Unexecuted instantiation: unicode.c:HASH_DEL_IN_BKT
Unexecuted instantiation: normalize.c:HASH_DEL_IN_BKT
Unexecuted instantiation: latin1.c:HASH_DEL_IN_BKT
Unexecuted instantiation: utf16.c:HASH_DEL_IN_BKT
Unexecuted instantiation: windows1252.c:HASH_DEL_IN_BKT
Unexecuted instantiation: shiftjis.c:HASH_DEL_IN_BKT
Unexecuted instantiation: shiftjis_codeindex.c:HASH_DEL_IN_BKT
Unexecuted instantiation: allocation.c:HASH_DEL_IN_BKT
Unexecuted instantiation: nativecall.c:HASH_DEL_IN_BKT
Unexecuted instantiation: nativecall_dyncall.c:HASH_DEL_IN_BKT
Unexecuted instantiation: continuation.c:HASH_DEL_IN_BKT
Unexecuted instantiation: intcache.c:HASH_DEL_IN_BKT
Unexecuted instantiation: fixedsizealloc.c:HASH_DEL_IN_BKT
Unexecuted instantiation: regionalloc.c:HASH_DEL_IN_BKT
Unexecuted instantiation: debugserver.c:HASH_DEL_IN_BKT
Unexecuted instantiation: config.c:HASH_DEL_IN_BKT
Unexecuted instantiation: orchestrate.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ext.c:HASH_DEL_IN_BKT
Unexecuted instantiation: worklist.c:HASH_DEL_IN_BKT
Unexecuted instantiation: roots.c:HASH_DEL_IN_BKT
Unexecuted instantiation: collect.c:HASH_DEL_IN_BKT
Unexecuted instantiation: gen2.c:HASH_DEL_IN_BKT
Unexecuted instantiation: wb.c:HASH_DEL_IN_BKT
objectid.c:HASH_DEL_IN_BKT
Line
Count
Source
488
89
MVM_STATIC_INLINE void HASH_DEL_IN_BKT(UT_hash_bucket *head, UT_hash_handle *hh_del) {
489
89
    head->count--;
490
89
    if (head->hh_head == hh_del) {
491
82
      head->hh_head = hh_del->hh_next;
492
82
    }
493
89
    if (hh_del->hh_prev) {
494
7
        hh_del->hh_prev->hh_next = hh_del->hh_next;
495
7
    }
496
89
    if (hh_del->hh_next) {
497
15
        hh_del->hh_next->hh_prev = hh_del->hh_prev;
498
15
    }
499
89
}
Unexecuted instantiation: finalize.c:HASH_DEL_IN_BKT
Unexecuted instantiation: debug.c:HASH_DEL_IN_BKT
Unexecuted instantiation: io.c:HASH_DEL_IN_BKT
Unexecuted instantiation: callstack.c:HASH_DEL_IN_BKT
Unexecuted instantiation: arch.c:HASH_DEL_IN_BKT
Unexecuted instantiation: callsite.c:HASH_DEL_IN_BKT
Unexecuted instantiation: args.c:HASH_DEL_IN_BKT
Unexecuted instantiation: exceptions.c:HASH_DEL_IN_BKT
Unexecuted instantiation: interp.c:HASH_DEL_IN_BKT
Unexecuted instantiation: threadcontext.c:HASH_DEL_IN_BKT
Unexecuted instantiation: compunit.c:HASH_DEL_IN_BKT
Unexecuted instantiation: bytecode.c:HASH_DEL_IN_BKT
Unexecuted instantiation: frame.c:HASH_DEL_IN_BKT
Unexecuted instantiation: eventloop.c:HASH_DEL_IN_BKT
Unexecuted instantiation: validation.c:HASH_DEL_IN_BKT
Unexecuted instantiation: bytecodedump.c:HASH_DEL_IN_BKT
Unexecuted instantiation: threads.c:HASH_DEL_IN_BKT
Unexecuted instantiation: ops.c:HASH_DEL_IN_BKT
Unexecuted instantiation: hll.c:HASH_DEL_IN_BKT
Unexecuted instantiation: loadbytecode.c:HASH_DEL_IN_BKT
Unexecuted instantiation: num.c:HASH_DEL_IN_BKT
Unexecuted instantiation: coerce.c:HASH_DEL_IN_BKT
Unexecuted instantiation: dll.c:HASH_DEL_IN_BKT
Unexecuted instantiation: Uninstantiable.c:HASH_DEL_IN_BKT
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_DEL_IN_BKT
Unexecuted instantiation: P6str.c:HASH_DEL_IN_BKT
Unexecuted instantiation: P6opaque.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMCode.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMOSHandle.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMCompUnit.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMStaticFrame.c:HASH_DEL_IN_BKT
Unexecuted instantiation: P6int.c:HASH_DEL_IN_BKT
Unexecuted instantiation: P6num.c:HASH_DEL_IN_BKT
Unexecuted instantiation: KnowHOWREPR.c:HASH_DEL_IN_BKT
Unexecuted instantiation: HashAttrStore.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMThread.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMIter.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMContext.c:HASH_DEL_IN_BKT
Unexecuted instantiation: SCRef.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMCallCapture.c:HASH_DEL_IN_BKT
Unexecuted instantiation: P6bigint.c:HASH_DEL_IN_BKT
Unexecuted instantiation: NFA.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMException.c:HASH_DEL_IN_BKT
Unexecuted instantiation: asyncsocketudp.c:HASH_DEL_IN_BKT
Unexecuted instantiation: syncfile.c:HASH_DEL_IN_BKT
Unexecuted instantiation: syncsocket.c:HASH_DEL_IN_BKT
Unexecuted instantiation: fileops.c:HASH_DEL_IN_BKT
Unexecuted instantiation: dirops.c:HASH_DEL_IN_BKT
Unexecuted instantiation: procops.c:HASH_DEL_IN_BKT
Unexecuted instantiation: timers.c:HASH_DEL_IN_BKT
Unexecuted instantiation: filewatchers.c:HASH_DEL_IN_BKT
Unexecuted instantiation: signals.c:HASH_DEL_IN_BKT
Unexecuted instantiation: asyncsocket.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMDLLSym.c:HASH_DEL_IN_BKT
Unexecuted instantiation: reprs.c:HASH_DEL_IN_BKT
Unexecuted instantiation: reprconv.c:HASH_DEL_IN_BKT
Unexecuted instantiation: containers.c:HASH_DEL_IN_BKT
Unexecuted instantiation: parametric.c:HASH_DEL_IN_BKT
Unexecuted instantiation: MVMString.c:HASH_DEL_IN_BKT
Unexecuted instantiation: VMArray.c:HASH_DEL_IN_BKT
MVMHash.c:HASH_DEL_IN_BKT
Line
Count
Source
488
146k
MVM_STATIC_INLINE void HASH_DEL_IN_BKT(UT_hash_bucket *head, UT_hash_handle *hh_del) {
489
146k
    head->count--;
490
146k
    if (head->hh_head == hh_del) {
491
116k
      head->hh_head = hh_del->hh_next;
492
116k
    }
493
146k
    if (hh_del->hh_prev) {
494
30.0k
        hh_del->hh_prev->hh_next = hh_del->hh_next;
495
30.0k
    }
496
146k
    if (hh_del->hh_next) {
497
24.2k
        hh_del->hh_next->hh_prev = hh_del->hh_prev;
498
24.2k
    }
499
146k
}
Unexecuted instantiation: MVMCFunction.c:HASH_DEL_IN_BKT
500
501
3.41M
#define HASH_CLEAR(tc, hh,head)                                                  \
502
3.41M
do {                                                                             \
503
3.41M
  if (head) {                                                                    \
504
176k
    uthash_free(tc, (head)->hh.tbl->buckets,                                     \
505
176k
                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
506
176k
    uthash_free(tc, (head)->hh.tbl, sizeof(UT_hash_table));                      \
507
176k
    (head)=NULL;                                                                 \
508
176k
  }                                                                              \
509
3.41M
} while(0)
510
511
/* obtain a count of items in the hash */
512
1.18M
#define HASH_CNT(hh,head) ((head)?((head)->hh.tbl->num_items):0)
513
514
MVM_STATIC_INLINE void * HASH_ITER_FIRST_ITEM(
515
6.60M
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
6.60M
    if (!ht)
517
5.45M
        return NULL;
518
4.41M
    while (*bucket_tmp < ht->num_buckets) {
519
4.41M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
4.41M
        if (hh_head)
521
1.14M
            return ELMT_FROM_HH(ht, hh_head);
522
3.26M
        (*bucket_tmp)++;
523
3.26M
    }
524
0
    return NULL;
525
1.14M
}
Unexecuted instantiation: manipulate.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: bootstrap.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: sc.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: serialization.c:HASH_ITER_FIRST_ITEM
compiler.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
2.43k
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
2.43k
    if (!ht)
517
178
        return NULL;
518
5.94k
    while (*bucket_tmp < ht->num_buckets) {
519
5.94k
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
5.94k
        if (hh_head)
521
2.25k
            return ELMT_FROM_HH(ht, hh_head);
522
3.68k
        (*bucket_tmp)++;
523
3.68k
    }
524
0
    return NULL;
525
2.25k
}
Unexecuted instantiation: driver.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: dump.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: graph.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: codegen.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: candidate.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: 6model.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: facts.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: optimize.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: dead_bb_elimination.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: deopt.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: log.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: threshold.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: inline.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: osr.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: lookup.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: Semaphore.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMContinuation.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: NativeCall.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CPointer.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CStr.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CArray.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CStruct.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CUnion.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ReentrantMutex.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ConditionVariable.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: iterator.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ConcBlockingQueue.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMAsyncTask.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMNull.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: CPPStruct.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: NativeRef.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MultiDimArray.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: Decoder.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMSpeshLog.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: moar.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: instrument.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: profile.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: heapsnapshot.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: telemeh.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: crossthreadwrite.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: line_coverage.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: sys.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: random.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: memmem32.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: bigintops.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: mmap.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: time.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: label.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: compile.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: expr.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: tile.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: linear_scan.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: interface.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: emit.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: utf8_c8.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: worker.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: stats.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: plan.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: arg_guard.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: plugin.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: decode_stream.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ascii.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: parse_num.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: utf8.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMMultiCache.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: nfg.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: unicode.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: normalize.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: latin1.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: utf16.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: windows1252.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: shiftjis.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: shiftjis_codeindex.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: worklist.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: nativecall_dyncall.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: continuation.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: intcache.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: fixedsizealloc.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: regionalloc.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: debugserver.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: config.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: orchestrate.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: allocation.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: nativecall.c:HASH_ITER_FIRST_ITEM
roots.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
1.43k
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
1.43k
    if (!ht)
517
759
        return NULL;
518
738
    while (*bucket_tmp < ht->num_buckets) {
519
738
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
738
        if (hh_head)
521
676
            return ELMT_FROM_HH(ht, hh_head);
522
62
        (*bucket_tmp)++;
523
62
    }
524
0
    return NULL;
525
676
}
Unexecuted instantiation: collect.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: gen2.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: wb.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: objectid.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: finalize.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: debug.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: io.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: eventloop.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: validation.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: callsite.c:HASH_ITER_FIRST_ITEM
args.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
2.08M
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
2.08M
    if (!ht)
517
2.01M
        return NULL;
518
249k
    while (*bucket_tmp < ht->num_buckets) {
519
249k
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
249k
        if (hh_head)
521
67.4k
            return ELMT_FROM_HH(ht, hh_head);
522
181k
        (*bucket_tmp)++;
523
181k
    }
524
0
    return NULL;
525
67.4k
}
Unexecuted instantiation: exceptions.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: interp.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: threadcontext.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: compunit.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: bytecode.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: frame.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: callstack.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: syncfile.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: bytecodedump.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: threads.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ops.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: hll.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: loadbytecode.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: num.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: coerce.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: dll.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: ext.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: HashAttrStore.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: P6str.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: P6opaque.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMCode.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMOSHandle.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMCompUnit.c:HASH_ITER_FIRST_ITEM
MVMStaticFrame.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
5.16k
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
5.16k
    if (!ht)
517
5.16k
        return NULL;
518
0
    while (*bucket_tmp < ht->num_buckets) {
519
0
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
0
        if (hh_head)
521
0
            return ELMT_FROM_HH(ht, hh_head);
522
0
        (*bucket_tmp)++;
523
0
    }
524
0
    return NULL;
525
0
}
Unexecuted instantiation: P6int.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: P6num.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: Uninstantiable.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMThread.c:HASH_ITER_FIRST_ITEM
MVMIter.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
383k
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
383k
    if (!ht)
517
11.9k
        return NULL;
518
1.28M
    while (*bucket_tmp < ht->num_buckets) {
519
1.28M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
1.28M
        if (hh_head)
521
371k
            return ELMT_FROM_HH(ht, hh_head);
522
911k
        (*bucket_tmp)++;
523
911k
    }
524
0
    return NULL;
525
371k
}
Unexecuted instantiation: MVMContext.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: SCRef.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMCallCapture.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: P6bigint.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: NFA.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMException.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMDLLSym.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: reprs.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: syncsocket.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: fileops.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: dirops.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: procops.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: timers.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: filewatchers.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: signals.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: asyncsocket.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: asyncsocketudp.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: arch.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: reprconv.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: containers.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: parametric.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: MVMString.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: VMArray.c:HASH_ITER_FIRST_ITEM
MVMHash.c:HASH_ITER_FIRST_ITEM
Line
Count
Source
515
4.12M
        struct UT_hash_table *ht, unsigned *bucket_tmp) {
516
4.12M
    if (!ht)
517
3.42M
        return NULL;
518
2.87M
    while (*bucket_tmp < ht->num_buckets) {
519
2.87M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
520
2.87M
        if (hh_head)
521
707k
            return ELMT_FROM_HH(ht, hh_head);
522
2.16M
        (*bucket_tmp)++;
523
2.16M
    }
524
0
    return NULL;
525
707k
}
Unexecuted instantiation: MVMCFunction.c:HASH_ITER_FIRST_ITEM
Unexecuted instantiation: KnowHOWREPR.c:HASH_ITER_FIRST_ITEM
526
MVM_STATIC_INLINE void * HASH_ITER_NEXT_ITEM(
527
2.39M
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
2.39M
    struct UT_hash_table *ht = cur_handle->tbl;
529
2.39M
    if (cur_handle->hh_next)
530
479k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
1.91M
    (*bucket_tmp)++;
532
5.98M
    while (*bucket_tmp < ht->num_buckets) {
533
4.83M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
4.83M
        if (hh_head)
535
761k
            return ELMT_FROM_HH(ht, hh_head);
536
4.07M
        (*bucket_tmp)++;
537
4.07M
    }
538
1.14M
    return NULL;
539
1.91M
}
Unexecuted instantiation: reprs.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: KnowHOWAttributeREPR.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: KnowHOWREPR.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMCFunction.c:HASH_ITER_NEXT_ITEM
MVMHash.c:HASH_ITER_NEXT_ITEM
Line
Count
Source
527
1.38M
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
1.38M
    struct UT_hash_table *ht = cur_handle->tbl;
529
1.38M
    if (cur_handle->hh_next)
530
302k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
1.08M
    (*bucket_tmp)++;
532
3.53M
    while (*bucket_tmp < ht->num_buckets) {
533
2.83M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
2.83M
        if (hh_head)
535
376k
            return ELMT_FROM_HH(ht, hh_head);
536
2.45M
        (*bucket_tmp)++;
537
2.45M
    }
538
707k
    return NULL;
539
1.08M
}
Unexecuted instantiation: VMArray.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMString.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: parametric.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: containers.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: reprconv.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: P6str.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: asyncsocketudp.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: asyncsocket.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: signals.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: filewatchers.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: timers.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: procops.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: dirops.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: fileops.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: syncsocket.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMThread.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMMultiCache.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMDLLSym.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMException.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: NFA.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: P6bigint.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMCallCapture.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: SCRef.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMContext.c:HASH_ITER_NEXT_ITEM
MVMIter.c:HASH_ITER_NEXT_ITEM
Line
Count
Source
527
868k
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
868k
    struct UT_hash_table *ht = cur_handle->tbl;
529
868k
    if (cur_handle->hh_next)
530
154k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
714k
    (*bucket_tmp)++;
532
2.06M
    while (*bucket_tmp < ht->num_buckets) {
533
1.69M
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
1.69M
        if (hh_head)
535
343k
            return ELMT_FROM_HH(ht, hh_head);
536
1.34M
        (*bucket_tmp)++;
537
1.34M
    }
538
371k
    return NULL;
539
714k
}
Unexecuted instantiation: syncfile.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: HashAttrStore.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: Uninstantiable.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: P6num.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: P6int.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMStaticFrame.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMCompUnit.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMOSHandle.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMCode.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: P6opaque.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: bytecodedump.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: nativecall.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ext.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: dll.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: coerce.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: num.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: loadbytecode.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: hll.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ops.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: threads.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: nativecall_dyncall.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: validation.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: callstack.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: frame.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: bytecode.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: compunit.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: threadcontext.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: interp.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: exceptions.c:HASH_ITER_NEXT_ITEM
args.c:HASH_ITER_NEXT_ITEM
Line
Count
Source
527
108k
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
108k
    struct UT_hash_table *ht = cur_handle->tbl;
529
108k
    if (cur_handle->hh_next)
530
8.98k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
99.8k
    (*bucket_tmp)++;
532
358k
    while (*bucket_tmp < ht->num_buckets) {
533
290k
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
290k
        if (hh_head)
535
32.3k
            return ELMT_FROM_HH(ht, hh_head);
536
258k
        (*bucket_tmp)++;
537
258k
    }
538
67.4k
    return NULL;
539
99.8k
}
Unexecuted instantiation: worklist.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: eventloop.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: io.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: debug.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: finalize.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: objectid.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: wb.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: gen2.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: collect.c:HASH_ITER_NEXT_ITEM
roots.c:HASH_ITER_NEXT_ITEM
Line
Count
Source
527
18.8k
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
18.8k
    struct UT_hash_table *ht = cur_handle->tbl;
529
18.8k
    if (cur_handle->hh_next)
530
11.8k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
6.98k
    (*bucket_tmp)++;
532
8.07k
    while (*bucket_tmp < ht->num_buckets) {
533
7.39k
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
7.39k
        if (hh_head)
535
6.31k
            return ELMT_FROM_HH(ht, hh_head);
536
1.08k
        (*bucket_tmp)++;
537
1.08k
    }
538
676
    return NULL;
539
6.98k
}
Unexecuted instantiation: MVMContinuation.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: allocation.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: orchestrate.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: config.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: debugserver.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: regionalloc.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: fixedsizealloc.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: intcache.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: continuation.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: utf8_c8.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: bigintops.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: shiftjis_codeindex.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: shiftjis.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: windows1252.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: utf16.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: latin1.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: normalize.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: unicode.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: nfg.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: instrument.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: utf8.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: parse_num.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ascii.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: decode_stream.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: plugin.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: arg_guard.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: plan.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: stats.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: worker.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: mmap.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: arch.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: emit.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: interface.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: linear_scan.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: tile.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: expr.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: compile.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: label.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: time.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: iterator.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: moar.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: memmem32.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: random.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: sys.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: line_coverage.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: crossthreadwrite.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: telemeh.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: heapsnapshot.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: profile.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ConcBlockingQueue.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: 6model.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMStaticFrameSpesh.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMSpeshLog.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: Decoder.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MultiDimArray.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: NativeRef.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CPPStruct.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMNull.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: MVMAsyncTask.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: bootstrap.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: Semaphore.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ConditionVariable.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: ReentrantMutex.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CUnion.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CStruct.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CArray.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CStr.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: CPointer.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: NativeCall.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: manipulate.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: lookup.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: osr.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: inline.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: threshold.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: log.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: deopt.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: dead_bb_elimination.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: optimize.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: facts.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: callsite.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: candidate.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: codegen.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: graph.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: dump.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: driver.c:HASH_ITER_NEXT_ITEM
compiler.c:HASH_ITER_NEXT_ITEM
Line
Count
Source
527
7.19k
        struct UT_hash_handle *cur_handle, unsigned *bucket_tmp) {
528
7.19k
    struct UT_hash_table *ht = cur_handle->tbl;
529
7.19k
    if (cur_handle->hh_next)
530
1.47k
        return ELMT_FROM_HH(ht, cur_handle->hh_next);
531
5.72k
    (*bucket_tmp)++;
532
14.3k
    while (*bucket_tmp < ht->num_buckets) {
533
12.0k
        struct UT_hash_handle *hh_head = ht->buckets[*bucket_tmp].hh_head;
534
12.0k
        if (hh_head)
535
3.47k
            return ELMT_FROM_HH(ht, hh_head);
536
8.62k
        (*bucket_tmp)++;
537
8.62k
    }
538
2.25k
    return NULL;
539
5.72k
}
Unexecuted instantiation: serialization.c:HASH_ITER_NEXT_ITEM
Unexecuted instantiation: sc.c:HASH_ITER_NEXT_ITEM
540
6.22M
#define HASH_ITER(hh,head,el,tmp,bucket_tmp)                                    \
541
6.22M
for((bucket_tmp) = 0,                                                           \
542
778k
    (el) = HASH_ITER_FIRST_ITEM((head) ? (head)->hh.tbl : NULL, &(bucket_tmp)), \
543
778k
    (tmp) = ((el) ? HASH_ITER_NEXT_ITEM(&((el)->hh), &(bucket_tmp)) : NULL);    \
544
7.74M
    (el);                                                                       \
545
1.52M
    (el) = (tmp),                                                               \
546
743k
    (tmp) = ((tmp) ? HASH_ITER_NEXT_ITEM(&((tmp)->hh), &(bucket_tmp)) : NULL))
547
548
#endif /* UTHASH_H */