_ZN11ArgsManagerD2Ev: 130| 2|ArgsManager::~ArgsManager() = default; _Z16htole32_internalj: 39| 4.28k|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 4.28k| else return host_32bits; 42| 4.28k|} _Z16le32toh_internalj: 49| 26.8M|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 26.8M| else return little_endian_32bits; 52| 26.8M|} _ZN15ChaCha20AlignedD2Ev: 42| 4|{ 43| 4| memory_cleanse(input, sizeof(input)); 44| 4|} _ZN8ChaCha20D2Ev: 332| 4|{ 333| 4| memory_cleanse(m_buffer.data(), m_buffer.size()); 334| 4|} _Z8ReadLE32ITk8ByteTypehEjPKT_: 28| 26.8M|{ 29| 26.8M| uint32_t x; 30| 26.8M| memcpy(&x, ptr, 4); 31| 26.8M| return le32toh_internal(x); 32| 26.8M|} _Z9WriteLE32ITk8ByteTypehEvPT_j: 51| 4.28k|{ 52| 4.28k| uint32_t v = htole32_internal(x); 53| 4.28k| memcpy(ptr, &v, 4); 54| 4.28k|} _ZN14poly1305_donna13poly1305_initEPNS_16poly1305_contextEPKh: 13| 1.07k|void poly1305_init(poly1305_context *st, const unsigned char key[32]) noexcept { 14| | /* r &= 0xffffffc0ffffffc0ffffffc0fffffff */ 15| 1.07k| st->r[0] = (ReadLE32(&key[ 0]) ) & 0x3ffffff; 16| 1.07k| st->r[1] = (ReadLE32(&key[ 3]) >> 2) & 0x3ffff03; 17| 1.07k| st->r[2] = (ReadLE32(&key[ 6]) >> 4) & 0x3ffc0ff; 18| 1.07k| st->r[3] = (ReadLE32(&key[ 9]) >> 6) & 0x3f03fff; 19| 1.07k| st->r[4] = (ReadLE32(&key[12]) >> 8) & 0x00fffff; 20| | 21| | /* h = 0 */ 22| 1.07k| st->h[0] = 0; 23| 1.07k| st->h[1] = 0; 24| 1.07k| st->h[2] = 0; 25| 1.07k| st->h[3] = 0; 26| 1.07k| st->h[4] = 0; 27| | 28| | /* save pad for later */ 29| 1.07k| st->pad[0] = ReadLE32(&key[16]); 30| 1.07k| st->pad[1] = ReadLE32(&key[20]); 31| 1.07k| st->pad[2] = ReadLE32(&key[24]); 32| 1.07k| st->pad[3] = ReadLE32(&key[28]); 33| | 34| 1.07k| st->leftover = 0; 35| 1.07k| st->final = 0; 36| 1.07k|} _ZN14poly1305_donna15poly1305_finishEPNS_16poly1305_contextEPh: 98| 1.07k|void poly1305_finish(poly1305_context *st, unsigned char mac[16]) noexcept { 99| 1.07k| uint32_t h0,h1,h2,h3,h4,c; 100| 1.07k| uint32_t g0,g1,g2,g3,g4; 101| 1.07k| uint64_t f; 102| 1.07k| uint32_t mask; 103| | 104| | /* process the remaining block */ 105| 1.07k| if (st->leftover) { ------------------ | Branch (105:9): [True: 702, False: 368] ------------------ 106| 702| size_t i = st->leftover; 107| 702| st->buffer[i++] = 1; 108| 6.33k| for (; i < POLY1305_BLOCK_SIZE; i++) { ------------------ | | 15| 6.33k|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (108:16): [True: 5.62k, False: 702] ------------------ 109| 5.62k| st->buffer[i] = 0; 110| 5.62k| } 111| 702| st->final = 1; 112| 702| poly1305_blocks(st, st->buffer, POLY1305_BLOCK_SIZE); ------------------ | | 15| 702|#define POLY1305_BLOCK_SIZE 16 ------------------ 113| 702| } 114| | 115| | /* fully carry h */ 116| 1.07k| h0 = st->h[0]; 117| 1.07k| h1 = st->h[1]; 118| 1.07k| h2 = st->h[2]; 119| 1.07k| h3 = st->h[3]; 120| 1.07k| h4 = st->h[4]; 121| | 122| 1.07k| c = h1 >> 26; h1 = h1 & 0x3ffffff; 123| 1.07k| h2 += c; c = h2 >> 26; h2 = h2 & 0x3ffffff; 124| 1.07k| h3 += c; c = h3 >> 26; h3 = h3 & 0x3ffffff; 125| 1.07k| h4 += c; c = h4 >> 26; h4 = h4 & 0x3ffffff; 126| 1.07k| h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff; 127| 1.07k| h1 += c; 128| | 129| | /* compute h + -p */ 130| 1.07k| g0 = h0 + 5; c = g0 >> 26; g0 &= 0x3ffffff; 131| 1.07k| g1 = h1 + c; c = g1 >> 26; g1 &= 0x3ffffff; 132| 1.07k| g2 = h2 + c; c = g2 >> 26; g2 &= 0x3ffffff; 133| 1.07k| g3 = h3 + c; c = g3 >> 26; g3 &= 0x3ffffff; 134| 1.07k| g4 = h4 + c - (1UL << 26); 135| | 136| | /* select h if h < p, or h + -p if h >= p */ 137| 1.07k| mask = (g4 >> ((sizeof(uint32_t) * 8) - 1)) - 1; 138| 1.07k| g0 &= mask; 139| 1.07k| g1 &= mask; 140| 1.07k| g2 &= mask; 141| 1.07k| g3 &= mask; 142| 1.07k| g4 &= mask; 143| 1.07k| mask = ~mask; 144| 1.07k| h0 = (h0 & mask) | g0; 145| 1.07k| h1 = (h1 & mask) | g1; 146| 1.07k| h2 = (h2 & mask) | g2; 147| 1.07k| h3 = (h3 & mask) | g3; 148| 1.07k| h4 = (h4 & mask) | g4; 149| | 150| | /* h = h % (2^128) */ 151| 1.07k| h0 = ((h0 ) | (h1 << 26)) & 0xffffffff; 152| 1.07k| h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff; 153| 1.07k| h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff; 154| 1.07k| h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff; 155| | 156| | /* mac = (h + pad) % (2^128) */ 157| 1.07k| f = (uint64_t)h0 + st->pad[0] ; h0 = (uint32_t)f; 158| 1.07k| f = (uint64_t)h1 + st->pad[1] + (f >> 32); h1 = (uint32_t)f; 159| 1.07k| f = (uint64_t)h2 + st->pad[2] + (f >> 32); h2 = (uint32_t)f; 160| 1.07k| f = (uint64_t)h3 + st->pad[3] + (f >> 32); h3 = (uint32_t)f; 161| | 162| 1.07k| WriteLE32(mac + 0, h0); 163| 1.07k| WriteLE32(mac + 4, h1); 164| 1.07k| WriteLE32(mac + 8, h2); 165| 1.07k| WriteLE32(mac + 12, h3); 166| | 167| | /* zero out the state */ 168| 1.07k| st->h[0] = 0; 169| 1.07k| st->h[1] = 0; 170| 1.07k| st->h[2] = 0; 171| 1.07k| st->h[3] = 0; 172| 1.07k| st->h[4] = 0; 173| 1.07k| st->r[0] = 0; 174| 1.07k| st->r[1] = 0; 175| 1.07k| st->r[2] = 0; 176| 1.07k| st->r[3] = 0; 177| 1.07k| st->r[4] = 0; 178| 1.07k| st->pad[0] = 0; 179| 1.07k| st->pad[1] = 0; 180| 1.07k| st->pad[2] = 0; 181| 1.07k| st->pad[3] = 0; 182| 1.07k|} _ZN14poly1305_donna15poly1305_updateEPNS_16poly1305_contextEPKhm: 184| 5.22k|void poly1305_update(poly1305_context *st, const unsigned char *m, size_t bytes) noexcept { 185| 5.22k| size_t i; 186| | 187| | /* handle leftover */ 188| 5.22k| if (st->leftover) { ------------------ | Branch (188:9): [True: 3.35k, False: 1.87k] ------------------ 189| 3.35k| size_t want = (POLY1305_BLOCK_SIZE - st->leftover); ------------------ | | 15| 3.35k|#define POLY1305_BLOCK_SIZE 16 ------------------ 190| 3.35k| if (want > bytes) { ------------------ | Branch (190:13): [True: 1.33k, False: 2.02k] ------------------ 191| 1.33k| want = bytes; 192| 1.33k| } 193| 20.5k| for (i = 0; i < want; i++) { ------------------ | Branch (193:21): [True: 17.2k, False: 3.35k] ------------------ 194| 17.2k| st->buffer[st->leftover + i] = m[i]; 195| 17.2k| } 196| 3.35k| bytes -= want; 197| 3.35k| m += want; 198| 3.35k| st->leftover += want; 199| 3.35k| if (st->leftover < POLY1305_BLOCK_SIZE) return; ------------------ | | 15| 3.35k|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (199:13): [True: 1.33k, False: 2.02k] ------------------ 200| 2.02k| poly1305_blocks(st, st->buffer, POLY1305_BLOCK_SIZE); ------------------ | | 15| 2.02k|#define POLY1305_BLOCK_SIZE 16 ------------------ 201| 2.02k| st->leftover = 0; 202| 2.02k| } 203| | 204| | /* process full blocks */ 205| 3.89k| if (bytes >= POLY1305_BLOCK_SIZE) { ------------------ | | 15| 3.89k|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (205:9): [True: 1.93k, False: 1.95k] ------------------ 206| 1.93k| size_t want = (bytes & ~(POLY1305_BLOCK_SIZE - 1)); ------------------ | | 15| 1.93k|#define POLY1305_BLOCK_SIZE 16 ------------------ 207| 1.93k| poly1305_blocks(st, m, want); 208| 1.93k| m += want; 209| 1.93k| bytes -= want; 210| 1.93k| } 211| | 212| | /* store leftover */ 213| 3.89k| if (bytes) { ------------------ | Branch (213:9): [True: 2.72k, False: 1.16k] ------------------ 214| 22.7k| for (i = 0; i < bytes; i++) { ------------------ | Branch (214:21): [True: 20.0k, False: 2.72k] ------------------ 215| 20.0k| st->buffer[st->leftover + i] = m[i]; 216| 20.0k| } 217| 2.72k| st->leftover += bytes; 218| 2.72k| } 219| 3.89k|} poly1305.cpp:_ZN14poly1305_donnaL15poly1305_blocksEPNS_16poly1305_contextEPKhm: 38| 4.65k|static void poly1305_blocks(poly1305_context *st, const unsigned char *m, size_t bytes) noexcept { 39| 4.65k| const uint32_t hibit = (st->final) ? 0 : (1UL << 24); /* 1 << 128 */ ------------------ | Branch (39:28): [True: 702, False: 3.95k] ------------------ 40| 4.65k| uint32_t r0,r1,r2,r3,r4; 41| 4.65k| uint32_t s1,s2,s3,s4; 42| 4.65k| uint32_t h0,h1,h2,h3,h4; 43| 4.65k| uint64_t d0,d1,d2,d3,d4; 44| 4.65k| uint32_t c; 45| | 46| 4.65k| r0 = st->r[0]; 47| 4.65k| r1 = st->r[1]; 48| 4.65k| r2 = st->r[2]; 49| 4.65k| r3 = st->r[3]; 50| 4.65k| r4 = st->r[4]; 51| | 52| 4.65k| s1 = r1 * 5; 53| 4.65k| s2 = r2 * 5; 54| 4.65k| s3 = r3 * 5; 55| 4.65k| s4 = r4 * 5; 56| | 57| 4.65k| h0 = st->h[0]; 58| 4.65k| h1 = st->h[1]; 59| 4.65k| h2 = st->h[2]; 60| 4.65k| h3 = st->h[3]; 61| 4.65k| h4 = st->h[4]; 62| | 63| 5.38M| while (bytes >= POLY1305_BLOCK_SIZE) { ------------------ | | 15| 5.38M|#define POLY1305_BLOCK_SIZE 16 ------------------ | Branch (63:12): [True: 5.37M, False: 4.65k] ------------------ 64| | /* h += m[i] */ 65| 5.37M| h0 += (ReadLE32(m+ 0) ) & 0x3ffffff; 66| 5.37M| h1 += (ReadLE32(m+ 3) >> 2) & 0x3ffffff; 67| 5.37M| h2 += (ReadLE32(m+ 6) >> 4) & 0x3ffffff; 68| 5.37M| h3 += (ReadLE32(m+ 9) >> 6) & 0x3ffffff; 69| 5.37M| h4 += (ReadLE32(m+12) >> 8) | hibit; 70| | 71| | /* h *= r */ 72| 5.37M| d0 = ((uint64_t)h0 * r0) + ((uint64_t)h1 * s4) + ((uint64_t)h2 * s3) + ((uint64_t)h3 * s2) + ((uint64_t)h4 * s1); 73| 5.37M| d1 = ((uint64_t)h0 * r1) + ((uint64_t)h1 * r0) + ((uint64_t)h2 * s4) + ((uint64_t)h3 * s3) + ((uint64_t)h4 * s2); 74| 5.37M| d2 = ((uint64_t)h0 * r2) + ((uint64_t)h1 * r1) + ((uint64_t)h2 * r0) + ((uint64_t)h3 * s4) + ((uint64_t)h4 * s3); 75| 5.37M| d3 = ((uint64_t)h0 * r3) + ((uint64_t)h1 * r2) + ((uint64_t)h2 * r1) + ((uint64_t)h3 * r0) + ((uint64_t)h4 * s4); 76| 5.37M| d4 = ((uint64_t)h0 * r4) + ((uint64_t)h1 * r3) + ((uint64_t)h2 * r2) + ((uint64_t)h3 * r1) + ((uint64_t)h4 * r0); 77| | 78| | /* (partial) h %= p */ 79| 5.37M| c = (uint32_t)(d0 >> 26); h0 = (uint32_t)d0 & 0x3ffffff; 80| 5.37M| d1 += c; c = (uint32_t)(d1 >> 26); h1 = (uint32_t)d1 & 0x3ffffff; 81| 5.37M| d2 += c; c = (uint32_t)(d2 >> 26); h2 = (uint32_t)d2 & 0x3ffffff; 82| 5.37M| d3 += c; c = (uint32_t)(d3 >> 26); h3 = (uint32_t)d3 & 0x3ffffff; 83| 5.37M| d4 += c; c = (uint32_t)(d4 >> 26); h4 = (uint32_t)d4 & 0x3ffffff; 84| 5.37M| h0 += c * 5; c = (h0 >> 26); h0 = h0 & 0x3ffffff; 85| 5.37M| h1 += c; 86| | 87| 5.37M| m += POLY1305_BLOCK_SIZE; ------------------ | | 15| 5.37M|#define POLY1305_BLOCK_SIZE 16 ------------------ 88| 5.37M| bytes -= POLY1305_BLOCK_SIZE; ------------------ | | 15| 5.37M|#define POLY1305_BLOCK_SIZE 16 ------------------ 89| 5.37M| } 90| | 91| 4.65k| st->h[0] = h0; 92| 4.65k| st->h[1] = h1; 93| 4.65k| st->h[2] = h2; 94| 4.65k| st->h[3] = h3; 95| 4.65k| st->h[4] = h4; 96| 4.65k|} _ZN8Poly1305C2ENSt3__14spanIKSt4byteLm18446744073709551615EEE: 51| 1.07k| { 52| 1.07k| assert(key.size() == KEYLEN); ------------------ | Branch (52:9): [True: 1.07k, False: 0] ------------------ 53| 1.07k| poly1305_donna::poly1305_init(&m_ctx, UCharCast(key.data())); 54| 1.07k| } _ZN8Poly13056UpdateENSt3__14spanIKSt4byteLm18446744073709551615EEE: 58| 5.22k| { 59| 5.22k| poly1305_donna::poly1305_update(&m_ctx, UCharCast(msg.data()), msg.size()); 60| 5.22k| return *this; 61| 5.22k| } _ZN8Poly13058FinalizeENSt3__14spanISt4byteLm18446744073709551615EEE: 65| 1.07k| { 66| 1.07k| assert(out.size() == TAGLEN); ------------------ | Branch (66:9): [True: 1.07k, False: 0] ------------------ 67| 1.07k| poly1305_donna::poly1305_finish(&m_ctx, UCharCast(out.data())); 68| 1.07k| } _ZN9ChainCodeD2Ev: 28| 2| ~ChainCode() { memory_cleanse(data(), size()); } _ZN11CNetCleanupD2Ev: 3676| 2| { 3677| |#ifdef WIN32 3678| | // Shutdown Windows Sockets 3679| | WSACleanup(); 3680| |#endif 3681| 2| } _ZNK9prevectorILj16EhjiE9is_directEv: 126| 16| bool is_direct() const { return _size <= N; } _ZN9prevectorILj16EhjiED2Ev: 422| 16| ~prevector() { 423| 16| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 16] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 16| } _ZNK9prevectorILj36EhjiE9is_directEv: 126| 14| bool is_direct() const { return _size <= N; } _ZN9prevectorILj36EhjiED2Ev: 422| 14| ~prevector() { 423| 14| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 14] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 14| } random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev: 367| 2| ~RNGState() = default; _ZN20BaseSignatureCheckerD2Ev: 298| 2| virtual ~BaseSignatureChecker() = default; _ZN20BaseSignatureCreatorD2Ev: 41| 4| virtual ~BaseSignatureCreator() = default; _ZN15SigningProviderD2Ev: 170| 2| virtual ~SigningProvider() = default; _Z9UCharCastPSt4byte: 98| 1.07k|inline unsigned char* UCharCast(std::byte* c) { return reinterpret_cast(c); } _Z9UCharCastPKSt4byte: 102| 6.29k|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast(c); } random.cpp:_ZN16secure_allocatorIN12_GLOBAL__N_18RNGStateEE10deallocateEPS1_m: 37| 2| { 38| 2| if (p != nullptr) { ------------------ | Branch (38:13): [True: 2, False: 0] ------------------ 39| 2| memory_cleanse(p, sizeof(T) * n); 40| 2| } 41| 2| LockedPoolManager::Instance().free(p); 42| 2| } _Z14memory_cleansePvm: 15| 14|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 14| std::memset(ptr, 0, len); 21| | 22| | /* Memory barrier that scares the compiler away from optimizing out the memset. 23| | * 24| | * Quoting Adam Langley in commit ad1907fe73334d6c696c8539646c21b11178f20f 25| | * in BoringSSL (ISC License): 26| | * As best as we can tell, this is sufficient to break any optimisations that 27| | * might try to eliminate "superfluous" memsets. 28| | * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it 29| | * is pretty efficient because the compiler can still implement the memset() efficiently, 30| | * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by 31| | * Yang et al. (USENIX Security 2017) for more background. 32| | */ 33| 14| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 14|#endif 35| 14|} _ZN5ArenaD2Ev: 48| 2|Arena::~Arena() = default; _ZN5Arena4freeEPv: 87| 2|{ 88| | // Freeing the nullptr pointer is OK. 89| 2| if (ptr == nullptr) { ------------------ | Branch (89:9): [True: 0, False: 2] ------------------ 90| 0| return; 91| 0| } 92| | 93| | // Remove chunk from used map 94| 2| auto i = chunks_used.find(ptr); 95| 2| if (i == chunks_used.end()) { ------------------ | Branch (95:9): [True: 0, False: 2] ------------------ 96| 0| throw std::runtime_error("Arena: invalid or double free"); 97| 0| } 98| 2| auto freed = std::make_pair(static_cast(i->first), i->second); 99| 2| chunks_used.erase(i); 100| | 101| | // coalesce freed with previous chunk 102| 2| auto prev = chunks_free_end.find(freed.first); 103| 2| if (prev != chunks_free_end.end()) { ------------------ | Branch (103:9): [True: 2, False: 0] ------------------ 104| 2| freed.first -= prev->second->first; 105| 2| freed.second += prev->second->first; 106| 2| size_to_free_chunk.erase(prev->second); 107| 2| chunks_free_end.erase(prev); 108| 2| } 109| | 110| | // coalesce freed with chunk after freed 111| 2| auto next = chunks_free.find(freed.first + freed.second); 112| 2| if (next != chunks_free.end()) { ------------------ | Branch (112:9): [True: 0, False: 2] ------------------ 113| 0| freed.second += next->second->first; 114| 0| size_to_free_chunk.erase(next->second); 115| 0| chunks_free.erase(next); 116| 0| } 117| | 118| | // Add/set space with coalesced free chunk 119| 2| auto it = size_to_free_chunk.emplace(freed.second, freed.first); 120| 2| chunks_free[freed.first] = it; 121| 2| chunks_free_end[freed.first + freed.second] = it; 122| 2|} _ZN24PosixLockedPageAllocator10FreeLockedEPvm: 254| 2|{ 255| 2| len = align_up(len, page_size); 256| 2| memory_cleanse(addr, len); 257| 2| munlock(addr, len); 258| 2| munmap(addr, len); 259| 2|} _ZN10LockedPoolD2Ev: 283| 2|LockedPool::~LockedPool() = default; _ZN10LockedPool4freeEPv: 308| 2|{ 309| 2| std::lock_guard lock(mutex); 310| | // TODO we can do better than this linear search by keeping a map of arena 311| | // extents to arena, and looking up the address. 312| 2| for (auto &arena: arenas) { ------------------ | Branch (312:21): [True: 2, False: 0] ------------------ 313| 2| if (arena.addressInArena(ptr)) { ------------------ | Branch (313:13): [True: 2, False: 0] ------------------ 314| 2| arena.free(ptr); 315| 2| return; 316| 2| } 317| 2| } 318| 0| throw std::runtime_error("LockedPool: invalid address not pointing to any arena"); 319| 2|} _ZN10LockedPool15LockedPageArenaD2Ev: 370| 2|{ 371| 2| allocator->FreeLocked(base, size); 372| 2|} _ZN17LockedPoolManager8InstanceEv: 405| 2|{ 406| 2| static std::once_flag init_flag; 407| 2| std::call_once(init_flag, LockedPoolManager::CreateInstance); 408| 2| return *LockedPoolManager::_instance; 409| 2|} lockedpool.cpp:_ZL8align_upmm: 32| 2|{ 33| 2| return (x + align - 1) & ~(align - 1); 34| 2|} _ZNK5Arena14addressInArenaEPv: 90| 2| bool addressInArena(void *ptr) const { return ptr >= base && ptr < end; } ------------------ | Branch (90:51): [True: 2, False: 0] | Branch (90:66): [True: 2, False: 0] ------------------ _ZN19LockedPageAllocatorD2Ev: 22| 2| virtual ~LockedPageAllocator() = default; _ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev: 96| 2| ~AnnotatedMixin() { 97| 2| DeleteLock((void*)this); 98| 2| } _ZN14AnnotatedMixinINSt3__15mutexEED2Ev: 96| 64| ~AnnotatedMixin() { 97| 64| DeleteLock((void*)this); 98| 64| } _Z10DeleteLockPv: 74| 66|inline void DeleteLock(void* cs) {} _Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE: 258| 30|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib: 181| 30| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 182| 30| { 183| 30| if (fTry) ------------------ | Branch (183:13): [True: 0, False: 30] ------------------ 184| 0| TryEnter(pszName, pszFile, nLine); 185| 30| else 186| 30| Enter(pszName, pszFile, nLine); 187| 30| } _Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b: 67| 30|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _Z13LeaveCriticalv: 68| 30|inline void LeaveCritical() {} _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i: 159| 30| { 160| 30| EnterCritical(pszName, pszFile, nLine, Base::mutex()); 161| |#ifdef DEBUG_LOCKCONTENTION 162| | if (!Base::try_lock()) { 163| | ContendedLock(pszName, pszFile, nLine, static_cast(*this)); 164| | } 165| |#else 166| 30| Base::lock(); 167| 30|#endif 168| 30| } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev: 201| 30| { 202| 30| if (Base::owns_lock()) ------------------ | Branch (202:13): [True: 30, False: 0] ------------------ 203| 30| LeaveCritical(); 204| 30| } _ZN18FuzzedDataProvider15remaining_bytesEv: 85| 5.22k| size_t remaining_bytes() { return remaining_bytes_; } _ZN18FuzzedDataProviderC2EPKhm: 37| 535| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEm: 109| 535|std::vector FuzzedDataProvider::ConsumeBytes(size_t num_bytes) { 110| 535| num_bytes = std::min(num_bytes, remaining_bytes_); 111| 535| return ConsumeBytes(num_bytes, num_bytes); 112| 535|} _ZN18FuzzedDataProvider12ConsumeBytesISt4byteEENSt3__16vectorIT_NS2_9allocatorIS4_EEEEmm: 352| 535|std::vector FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) { 353| 535| static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type."); 354| | 355| | // The point of using the size-based constructor below is to increase the 356| | // odds of having a vector object with capacity being equal to the length. 357| | // That part is always implementation specific, but at least both libc++ and 358| | // libstdc++ allocate the requested number of bytes in that constructor, 359| | // which seems to be a natural choice for other implementations as well. 360| | // To increase the odds even more, we also call |shrink_to_fit| below. 361| 535| std::vector result(size); 362| 535| if (size == 0) { ------------------ | Branch (362:7): [True: 0, False: 535] ------------------ 363| 0| if (num_bytes != 0) ------------------ | Branch (363:9): [True: 0, False: 0] ------------------ 364| 0| abort(); 365| 0| return result; 366| 0| } 367| | 368| 535| CopyAndAdvance(result.data(), num_bytes); 369| | 370| | // Even though |shrink_to_fit| is also implementation specific, we expect it 371| | // to provide an additional assurance in case vector's constructor allocated 372| | // a buffer which is larger than the actual amount of data we put inside it. 373| 535| result.shrink_to_fit(); 374| 535| return result; 375| 535|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm: 153| 4.69k|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) { 154| | // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\" 155| | // followed by anything else to the end of the string. As a result of this 156| | // logic, a fuzzer can insert characters into the string, and the string 157| | // will be lengthened to include those new characters, resulting in a more 158| | // stable fuzzer than picking the length of a string independently from 159| | // picking its contents. 160| 4.69k| std::string result; 161| | 162| | // Reserve the anticipated capacity to prevent several reallocations. 163| 4.69k| result.reserve(std::min(max_length, remaining_bytes_)); 164| 43.0M| for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) { ------------------ | Branch (164:22): [True: 43.0M, False: 385] | Branch (164:40): [True: 43.0M, False: 31] ------------------ 165| 43.0M| char next = ConvertUnsignedToSigned(data_ptr_[0]); 166| 43.0M| Advance(1); 167| 43.0M| if (next == '\\' && remaining_bytes_ != 0) { ------------------ | Branch (167:9): [True: 5.37k, False: 43.0M] | Branch (167:25): [True: 5.33k, False: 44] ------------------ 168| 5.33k| next = ConvertUnsignedToSigned(data_ptr_[0]); 169| 5.33k| Advance(1); 170| 5.33k| if (next != '\\') ------------------ | Branch (170:11): [True: 4.27k, False: 1.05k] ------------------ 171| 4.27k| break; 172| 5.33k| } 173| 43.0M| result += next; 174| 43.0M| } 175| | 176| 4.69k| result.shrink_to_fit(); 177| 4.69k| return result; 178| 4.69k|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv: 181| 4.69k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() { 182| 4.69k| return ConsumeRandomLengthString(remaining_bytes_); 183| 4.69k|} _ZN18FuzzedDataProvider14CopyAndAdvanceEPvm: 338| 535| size_t num_bytes) { 339| 535| std::memcpy(destination, data_ptr_, num_bytes); 340| 535| Advance(num_bytes); 341| 535|} _ZN18FuzzedDataProvider7AdvanceEm: 343| 43.0M|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 344| 43.0M| if (num_bytes > remaining_bytes_) ------------------ | Branch (344:7): [True: 0, False: 43.0M] ------------------ 345| 0| abort(); 346| | 347| 43.0M| data_ptr_ += num_bytes; 348| 43.0M| remaining_bytes_ -= num_bytes; 349| 43.0M|} _ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_: 378| 43.0M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) { 379| 43.0M| static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types."); 380| 43.0M| static_assert(!std::numeric_limits::is_signed, 381| 43.0M| "Source type must be unsigned."); 382| | 383| | if constexpr (std::numeric_limits::is_modulo) 384| | return static_cast(value); 385| | 386| | // Avoid using implementation-defined unsigned to signed conversions. 387| | // To learn more, see https://stackoverflow.com/questions/13150449. 388| 43.0M| constexpr auto TS_max = static_cast(std::numeric_limits::max()); 389| 43.0M| if (value <= TS_max) { ------------------ | Branch (389:7): [True: 39.1M, False: 3.87M] ------------------ 390| 39.1M| return static_cast(value); 391| 39.1M| } else { 392| 3.87M| constexpr auto TS_min = std::numeric_limits::min(); 393| 3.87M| return TS_min + static_cast(value - TS_min); 394| 3.87M| } 395| 43.0M|} _Z33crypto_poly1305_split_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 25| 535|{ 26| 535| FuzzedDataProvider provider{buffer.data(), buffer.size()}; 27| | 28| | // Read key and instantiate two Poly1305 objects with it. 29| 535| auto key = provider.ConsumeBytes(Poly1305::KEYLEN); 30| 535| key.resize(Poly1305::KEYLEN); 31| 535| Poly1305 poly_full{key}, poly_split{key}; 32| | 33| | // Vector that holds all bytes processed so far. 34| 535| std::vector total_input; 35| | 36| | // Process input in pieces. 37| 4.69k| LIMITED_WHILE (provider.remaining_bytes(), 100) { ------------------ | | 23| 5.22k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 4.70k, False: 525] | | | Branch (23:49): [True: 4.69k, False: 10] | | ------------------ ------------------ 38| 4.69k| auto in = ConsumeRandomLengthByteVector(provider); 39| 4.69k| poly_split.Update(in); 40| | // Update total_input to match what was processed. 41| 4.69k| total_input.insert(total_input.end(), in.begin(), in.end()); 42| 4.69k| } 43| | 44| | // Process entire input at once. 45| 535| poly_full.Update(total_input); 46| | 47| | // Verify both agree. 48| 535| std::array tag_split, tag_full; 49| 535| poly_split.Finalize(tag_split); 50| 535| poly_full.Finalize(tag_full); 51| | assert(tag_full == tag_split); ------------------ | Branch (51:5): [True: 535, False: 0] ------------------ 52| 535|} LLVMFuzzerTestOneInput: 213| 535|{ 214| 535| test_one_input({data, size}); 215| 535| return 0; 216| 535|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 535|{ 85| 535| CheckGlobals check{}; 86| 535| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 535|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 535|} _Z29ConsumeRandomLengthByteVectorISt4byteENSt3__16vectorIT_NS1_9allocatorIS3_EEEER18FuzzedDataProviderRKNS1_8optionalImEE: 64| 4.69k|{ 65| 4.69k| static_assert(sizeof(B) == 1); 66| 4.69k| const std::string s = max_length ? ------------------ | Branch (66:27): [True: 0, False: 4.69k] ------------------ 67| 0| fuzzed_data_provider.ConsumeRandomLengthString(*max_length) : 68| 4.69k| fuzzed_data_provider.ConsumeRandomLengthString(); 69| 4.69k| std::vector ret(s.size()); 70| 4.69k| std::copy(s.begin(), s.end(), reinterpret_cast(ret.data())); 71| 4.69k| return ret; 72| 4.69k|} _ZN12CheckGlobalsC2Ev: 59| 535|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 537|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 535| { 18| 535| g_used_g_prng = false; 19| 535| g_seeded_g_prng_zero = false; 20| 535| g_used_system_time = false; 21| 535| SetMockTime(0s); 22| 535| MockableSteadyClock::ClearMockTime(); 23| 535| } _ZN16CheckGlobalsImplD2Ev: 25| 537| { 26| 537| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 537] | Branch (26:30): [True: 0, False: 0] ------------------ 27| 0| std::cerr << "\n\n" 28| 0| "The current fuzz target used the global random state.\n\n" 29| | 30| 0| "This is acceptable, but requires the fuzz target to call \n" 31| 0| "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n" 32| 0| "of the FUZZ_TARGET function.\n\n" 33| | 34| 0| "An alternative solution would be to avoid any use of globals.\n\n" 35| | 36| 0| "Without a solution, fuzz instability and non-determinism can lead \n" 37| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 38| 0| << std::endl; 39| 0| std::abort(); // Abort, because AFL may try to recover from a std::exit 40| 0| } 41| | 42| 537| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 537] ------------------ 43| 0| std::cerr << "\n\n" 44| 0| "The current fuzz target accessed system time.\n\n" 45| | 46| 0| "This is acceptable, but requires the fuzz target to use \n" 47| 0| "a FakeNodeClock, FakeSteadyClock or call \n" 48| 0| "SetMockTime() at the \n" "beginning of processing the \n" 49| 0| "fuzz input.\n\n" 50| | 51| 0| "Without setting mock time, time-dependent behavior can lead \n" 52| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 53| 0| << std::endl; 54| 0| std::abort(); 55| 0| } 56| 537| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN9base_blobILj256EE4dataEv: 99| 2| constexpr unsigned char* data() { return m_data.data(); } _ZN9base_blobILj256EE4sizeEv: 107| 2| static constexpr unsigned int size() { return WIDTH; } _ZN10btcsignals6signalIFvvENS_10null_valueEED2Ev: 175| 6| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStatellbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStateRK11CBlockIndexdENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFviENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFbRK13bilingual_strRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjENS_6any_ofEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRK13bilingual_strjENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE: 90| 535|{ 91| 535| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 535, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 535| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 535] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 535| } 96| 535| return std::forward(val); 97| 535|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 535|{ 91| 535| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 535, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 535| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 535] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 535| } 96| 535| return std::forward(val); 97| 535|} _Z22inline_assertion_checkILb0EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 10|{ 91| 10| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [Folded, False: 0] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 10| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 10] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 10| } 96| 10| return std::forward(val); 97| 10|} _ZN16CThreadInterruptD2Ev: 32| 4| virtual ~CThreadInterrupt() = default; _ZN10ThreadPoolD2Ev: 93| 10| { 94| 10| Stop(); // In case it hasn't been stopped. 95| 10| } _ZN10ThreadPool4StopEv: 129| 10| { 130| | // Notify workers and join them 131| 10| std::vector threads_to_join; 132| 10| { 133| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 134| | // Ensure Stop() is not called from a worker thread while workers are still registered, 135| | // otherwise a self-join deadlock would occur. 136| 10| auto id = std::this_thread::get_id(); 137| 10| for (const auto& worker : m_workers) assert(worker.get_id() != id); ------------------ | Branch (137:37): [True: 0, False: 10] | Branch (137:50): [True: 0, False: 0] ------------------ 138| | // Early shutdown to return right away on any concurrent Submit() call 139| 10| m_interrupt = true; 140| 10| threads_to_join.swap(m_workers); 141| 10| } 142| 0| m_cv.notify_all(); 143| | // Help draining queue 144| 10| while (ProcessTask()) {} ------------------ | Branch (144:16): [True: 0, False: 10] ------------------ 145| | // Free resources 146| 10| for (auto& worker : threads_to_join) worker.join(); ------------------ | Branch (146:27): [True: 0, False: 10] ------------------ 147| | 148| | // Since we currently wait for tasks completion, sanity-check empty queue 149| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 150| 10| Assume(m_work_queue.empty()); ------------------ | | 128| 10|#define Assume(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 151| | // Re-allow Start() now that all workers have exited 152| 10| m_interrupt = false; 153| 10| } _ZN10ThreadPool11ProcessTaskEv: 244| 10| { 245| 10| std::packaged_task task; 246| 10| { 247| 10| LOCK(m_mutex); ------------------ | | 268| 10|#define LOCK(cs) UniqueLock BITCOIN_UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 10|#define BITCOIN_UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 10|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 10|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 248| 10| if (m_work_queue.empty()) return false; ------------------ | Branch (248:17): [True: 10, False: 0] ------------------ 249| | 250| | // Pop the task 251| 0| task = std::move(m_work_queue.front()); 252| 0| m_work_queue.pop(); 253| 0| } 254| 0| task(); 255| 0| return true; 256| 10| } _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 54| 535|{ 55| 535| Assert(mock_time_in >= 0s); ------------------ | | 116| 535|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 535| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 535|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 535|{ 85| 535| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 535|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;