bit_ctz_u64: 349| 535|{ 350| 535|#if defined(HAVE_BUILTIN_CTZLL) 351| 535| return __builtin_ctzll(x); 352| |#elif defined(HAVE_FFSLL) 353| | return ffsll(x) - 1; 354| |#else 355| | CTZ_NAIVE(x, sizeof(uint64_t) * CHAR_BIT); 356| |#endif 357| 535|} bit_iterator_init: 634| 49|{ 635| 49| it->start = (const char *) data; 636| 49| it->next = it->start; 637| 49| it->end = it->next + size; 638| 49| if (bit_unlikely(size == 0)) { ------------------ | | 55| 49|#define bit_unlikely(x) __builtin_expect((x),0) | | ------------------ | | | Branch (55:26): [True: 0, False: 49] | | ------------------ ------------------ 639| 0| it->word = 0; 640| 0| return; 641| 0| } 642| | 643| 49| it->word_xor = set ? 0 : (ITER_UINT) -1; ------------------ | Branch (643:17): [True: 49, False: 0] ------------------ 644| 49| it->word_base = 0; 645| | 646| | /* Check if size is a multiple of sizeof(ITER_UINT) */ 647| 49| if (bit_likely(size % sizeof(ITER_UINT) == 0)) { ------------------ | | 54| 49|#define bit_likely(x) __builtin_expect((x),1) | | ------------------ | | | Branch (54:26): [True: 0, False: 49] | | ------------------ ------------------ 648| 0| it->word = ITER_LOAD(it->next); ------------------ | | 596| 0|#define ITER_LOAD load_u64 ------------------ 649| 0| it->next += sizeof(ITER_UINT); 650| 49| } else { 651| 49| const char *e = it->next + size % sizeof(ITER_UINT); 652| 49| it->word = it->word_xor; 653| 49| char *w = (char *) &it->word; 654| 245| while (it->next < e) ------------------ | Branch (654:10): [True: 196, False: 49] ------------------ 655| 196| *w++ = *it->next++; 656| 49| } 657| 49| it->word ^= it->word_xor; 658| 49|} bit_iterator_next: 669| 584|{ 670| 584| while (bit_unlikely(it->word == 0)) { ------------------ | | 55| 584|#define bit_unlikely(x) __builtin_expect((x),0) | | ------------------ | | | Branch (55:26): [True: 49, False: 535] | | ------------------ ------------------ 671| 49| if (bit_unlikely(it->next >= it->end)) ------------------ | | 55| 49|#define bit_unlikely(x) __builtin_expect((x),0) | | ------------------ | | | Branch (55:26): [True: 49, False: 0] | | ------------------ ------------------ 672| 49| return SIZE_MAX; 673| | 674| | /* Extract the next word from memory */ 675| 0| it->word = ITER_LOAD(it->next); ------------------ | | 596| 0|#define ITER_LOAD load_u64 ------------------ 676| 0| it->word ^= it->word_xor; 677| 0| it->word_base = (it->next - it->start) * CHAR_BIT; 678| 0| it->next += sizeof(ITER_UINT); 679| 0| } 680| | 681| | /* Find the position of a first trailing bit in the current word */ 682| 535| int bit = ITER_CTZ(it->word); ------------------ | | 595| 535|#define ITER_CTZ bit_ctz_u64 ------------------ 683| | /* Remove the first trailing bit from the current word */ 684| 535| it->word &= it->word - 1; 685| | /* Add start position if the current word to the found bit */ 686| 535| return it->word_base + bit; 687| 584|} vclock_from_string: 84| 454|{ 85| 454| long replica_id; 86| 454| long long lsn; 87| | 88| 454| const char *p = str; 89| 649| begin: 90| 649| if (*p == '{') { ------------------ | Branch (90:7): [True: 428, False: 221] ------------------ 91| 428| ++p; 92| 428| goto key; 93| 428| } else if (isblank(*p)) { 94| 195| ++p; 95| 195| goto begin; 96| 195| } 97| 26| goto error; 98| 1.56k| key: 99| 1.56k| if (isdigit(*p)) { 100| 1.30k| errno = 0; 101| 1.30k| replica_id = strtol(p, (char **) &p, 10); 102| 1.30k| if (errno != 0 || replica_id < 0 || replica_id >= VCLOCK_MAX) ------------------ | Branch (102:8): [True: 1, False: 1.30k] | Branch (102:22): [True: 0, False: 1.30k] | Branch (102:40): [True: 80, False: 1.22k] ------------------ 103| 81| goto error; 104| 1.22k| goto sep; 105| 1.30k| } else if (*p == '}') { ------------------ | Branch (105:14): [True: 26, False: 229] ------------------ 106| 26| ++p; 107| 26| goto end; 108| 229| } else if (isblank(*p)) { 109| 194| ++p; 110| 194| goto key; 111| 194| } 112| 35| goto error; 113| 1.42k| sep: 114| 1.42k| if (*p == ':') { ------------------ | Branch (114:7): [True: 1.19k, False: 230] ------------------ 115| 1.19k| ++p; 116| 1.19k| goto val; 117| 1.19k| } else if (isblank(*p)) { 118| 197| ++p; 119| 197| goto sep; 120| 197| } 121| 33| goto error; 122| 1.38k| val: 123| 1.38k| if (isblank(*p)) { 124| 194| ++p; 125| 194| goto val; 126| 1.19k| } else if (isdigit(*p)) { 127| 1.18k| errno = 0; 128| 1.18k| lsn = strtoll(p, (char **) &p, 10); 129| 1.18k| if (errno != 0 || lsn < 0 || lsn > INT64_MAX || ------------------ | Branch (129:8): [True: 1, False: 1.18k] | Branch (129:22): [True: 0, False: 1.18k] | Branch (129:33): [True: 0, False: 1.18k] ------------------ 130| 1.18k| replica_id >= VCLOCK_MAX || ------------------ | Branch (130:8): [True: 0, False: 1.18k] ------------------ 131| 1.18k| vclock_get(vclock, replica_id) > 0) ------------------ | Branch (131:8): [True: 64, False: 1.11k] ------------------ 132| 65| goto error; 133| 1.11k| vclock->map |= 1U << replica_id; 134| 1.11k| vclock->lsn[replica_id] = lsn; 135| 1.11k| goto comma; 136| 1.18k| } 137| 9| goto error; 138| 1.31k| comma: 139| 1.31k| if (isspace(*p)) { 140| 194| ++p; 141| 194| goto comma; 142| 1.11k| } else if (*p == '}') { ------------------ | Branch (142:14): [True: 39, False: 1.07k] ------------------ 143| 39| ++p; 144| 39| goto end; 145| 1.07k| } else if (*p == ',') { ------------------ | Branch (145:14): [True: 938, False: 140] ------------------ 146| 938| ++p; 147| 938| goto key; 148| 938| } 149| 140| goto error; 150| 260| end: 151| 260| if (*p == '\0') { ------------------ | Branch (151:7): [True: 49, False: 211] ------------------ 152| 49| vclock->signature = vclock_calc_sum(vclock); 153| 49| return 0; 154| 211| } else if (isblank(*p)) { 155| 195| ++p; 156| 195| goto end; 157| 195| } 158| | /* goto error; */ 159| 405| error: 160| 405| return p - str + 1; /* error */ 161| 260|} vclock_from_string_fuzzer.c:vclock_create: 118| 454|{ 119| 454| vclock->signature = 0; 120| 454| vclock->map = 0; 121| 454| vclock->lsn[0] = 0; 122| 454|} vclock.c:vclock_get: 148| 1.18k|{ 149| 1.18k| assert(replica_id < VCLOCK_MAX); 150| | /* Evaluate a bitmask to avoid branching. */ 151| 1.18k| int64_t mask = 0ULL - ((vclock->map >> replica_id) & 0x1); 152| 1.18k| return mask & vclock->lsn[replica_id]; 153| 1.18k|} vclock.c:vclock_calc_sum: 226| 49|{ 227| 49| int64_t sum = 0; 228| 49| struct vclock_iterator it; 229| 49| vclock_iterator_init(&it, vclock); 230| 49| vclock_foreach(&it, replica) ------------------ | | 113| 49| for (struct vclock_c var = vclock_iterator_next(it); \ | | 114| 584| (var).id < VCLOCK_MAX; (var) = vclock_iterator_next(it)) | | ------------------ | | | Branch (114:7): [True: 535, False: 49] | | ------------------ ------------------ 231| 535| sum += replica.lsn; 232| 49| return sum; 233| 49|} vclock.c:vclock_iterator_init: 95| 49|{ 96| 49| it->vclock = vclock; 97| 49| bit_iterator_init(&it->it, &vclock->map, sizeof(vclock->map), true); 98| 49|} vclock.c:vclock_iterator_next: 102| 584|{ 103| 584| struct vclock_c c = { 0, 0 }; 104| 584| size_t id = bit_iterator_next(&it->it); 105| 584| c.id = id == SIZE_MAX ? (int) VCLOCK_MAX : id; ------------------ | Branch (105:9): [True: 49, False: 535] ------------------ 106| 584| if (c.id < VCLOCK_MAX) ------------------ | Branch (106:6): [True: 535, False: 49] ------------------ 107| 535| c.lsn = it->vclock->lsn[c.id]; 108| 584| return c; 109| 584|} LLVMFuzzerTestOneInput: 9| 454|{ 10| 454| char *buf = xcalloc(size + 1, sizeof(char)); ------------------ | | 130| 454|#define xcalloc(n, size) xalloc_impl((n) * (size), calloc, (n), (size)) | | ------------------ | | | | 122| 454| ({ \ | | | | 123| 454| void *ret = func(args); \ | | | | 124| 454| if (unlikely(ret == NULL)) \ | | | | ------------------ | | | | | | 227| 454|# define unlikely(x) __builtin_expect(!! (x),0) | | | | | | ------------------ | | | | | | | Branch (227:24): [True: 0, False: 454] | | | | | | ------------------ | | | | ------------------ | | | | 125| 454| alloc_failure(__FILE__, __LINE__, (size)); \ | | | | 126| 454| ret; \ | | | | 127| 454| }) | | ------------------ ------------------ 11| 454| assert(buf); 12| 454| memcpy(buf, data, size); 13| 454| buf[size] = '\0'; 14| | 15| 454| struct vclock vclock; 16| 454| vclock_create(&vclock); 17| 454| vclock_from_string(&vclock, buf); 18| 454| free(buf); 19| | 20| 454| return 0; 21| 454|}