_ZN11ArgsManagerD2Ev: 130| 2|ArgsManager::~ArgsManager() = default; _Z16htole64_internalm: 59| 1.27G|{ 60| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits); 61| 1.27G| else return host_64bits; 62| 1.27G|} _Z16htole32_internalj: 39| 374k|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 374k| else return host_32bits; 42| 374k|} _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|} _Z9WriteLE32ITk8ByteTypeSt4byteEvPT_j: 51| 374k|{ 52| 374k| uint32_t v = htole32_internal(x); 53| 374k| memcpy(ptr, &v, 4); 54| 374k|} _Z9WriteLE64ITk8ByteTypeSt4byteEvPT_m: 58| 1.27G|{ 59| 1.27G| uint64_t v = htole64_internal(x); 60| 1.27G| memcpy(ptr, &v, 8); 61| 1.27G|} _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; _ZN11RandomMixinI21InsecureRandomContextE8fillrandENSt3__14spanISt4byteLm18446744073709551615EEE: 268| 4.54M| { 269| 1.27G| while (span.size() >= 8) { ------------------ | Branch (269:16): [True: 1.27G, False: 4.54M] ------------------ 270| 1.27G| uint64_t gen = Impl().rand64(); 271| 1.27G| WriteLE64(span.data(), gen); 272| 1.27G| span = span.subspan(8); 273| 1.27G| } 274| 4.54M| if (span.size() >= 4) { ------------------ | Branch (274:13): [True: 374k, False: 4.17M] ------------------ 275| 374k| uint32_t gen = Impl().rand32(); 276| 374k| WriteLE32(span.data(), gen); 277| 374k| span = span.subspan(4); 278| 374k| } 279| 6.62M| while (span.size()) { ------------------ | Branch (279:16): [True: 2.07M, False: 4.54M] ------------------ 280| 2.07M| span[0] = std::byte(Impl().template randbits<8>()); 281| 2.07M| span = span.subspan(1); 282| 2.07M| } 283| 4.54M| } _ZN11RandomMixinI21InsecureRandomContextE6rand32Ev: 314| 374k| uint32_t rand32() noexcept { return Impl().template randbits<32>(); } _ZN11RandomMixinI21InsecureRandomContextE8randbitsILi32EEEmv: 231| 374k| { 232| 374k| static_assert(Bits >= 0 && Bits <= 64); 233| | if constexpr (Bits == 64) { 234| | return Impl().rand64(); 235| 374k| } else { 236| 374k| uint64_t ret; 237| 374k| if (Bits <= bitbuf_size) { ------------------ | Branch (237:17): [True: 0, False: 374k] ------------------ 238| 0| ret = bitbuf; 239| 0| bitbuf >>= Bits; 240| 0| bitbuf_size -= Bits; 241| 374k| } else { 242| 374k| uint64_t gen = Impl().rand64(); 243| 374k| ret = (gen << bitbuf_size) | bitbuf; 244| 374k| bitbuf = gen >> (Bits - bitbuf_size); 245| 374k| bitbuf_size = 64 + bitbuf_size - Bits; 246| 374k| } 247| 374k| constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1; 248| 374k| return ret & MASK; 249| 374k| } 250| 374k| } _ZN11RandomMixinI21InsecureRandomContextE8randbitsILi8EEEmv: 231| 2.07M| { 232| 2.07M| static_assert(Bits >= 0 && Bits <= 64); 233| | if constexpr (Bits == 64) { 234| | return Impl().rand64(); 235| 2.07M| } else { 236| 2.07M| uint64_t ret; 237| 2.07M| if (Bits <= bitbuf_size) { ------------------ | Branch (237:17): [True: 770k, False: 1.30M] ------------------ 238| 770k| ret = bitbuf; 239| 770k| bitbuf >>= Bits; 240| 770k| bitbuf_size -= Bits; 241| 1.30M| } else { 242| 1.30M| uint64_t gen = Impl().rand64(); 243| 1.30M| ret = (gen << bitbuf_size) | bitbuf; 244| 1.30M| bitbuf = gen >> (Bits - bitbuf_size); 245| 1.30M| bitbuf_size = 64 + bitbuf_size - Bits; 246| 1.30M| } 247| 2.07M| constexpr uint64_t MASK = (uint64_t{1} << Bits) - 1; 248| 2.07M| return ret & MASK; 249| 2.07M| } 250| 2.07M| } _ZN21InsecureRandomContextC2Em: 439| 4.54M| : m_s0(SplitMix64(seedval)), m_s1(SplitMix64(seedval)) {} _ZN11RandomMixinI21InsecureRandomContextEC2Ev: 195| 4.54M| constexpr RandomMixin() noexcept = default; _ZN21InsecureRandomContext10SplitMix64ERm: 430| 9.09M| { 431| 9.09M| uint64_t z = (seedval += 0x9e3779b97f4a7c15); 432| 9.09M| z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9; 433| 9.09M| z = (z ^ (z >> 27)) * 0x94d049bb133111eb; 434| 9.09M| return z ^ (z >> 31); 435| 9.09M| } _ZN21InsecureRandomContext6rand64Ev: 449| 1.27G| { 450| 1.27G| uint64_t s0 = m_s0, s1 = m_s1; 451| 1.27G| const uint64_t result = std::rotl(s0 + s1, 17) + s0; 452| 1.27G| s1 ^= s0; 453| 1.27G| m_s0 = std::rotl(s0, 49) ^ s1 ^ (s1 << 21); 454| 1.27G| m_s1 = std::rotl(s1, 28); 455| 1.27G| return result; 456| 1.27G| } _ZN11RandomMixinI21InsecureRandomContextE4ImplEv: 185| 1.27G| RandomNumberGenerator auto& Impl() noexcept { return static_cast(*this); } _ZN20BaseSignatureCheckerD2Ev: 298| 2| virtual ~BaseSignatureChecker() = default; _ZN20BaseSignatureCreatorD2Ev: 41| 4| virtual ~BaseSignatureCreator() = default; _ZN15SigningProviderD2Ev: 170| 2| virtual ~SigningProvider() = default; _ZN12PoolResourceILm128ELm1EEC2Em: 184| 522| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 522| { 186| 522| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 522, False: 0] ------------------ 187| 522| AllocateChunk(); 188| 522| } _ZN12PoolResourceILm128ELm1EE17NumElemAlignBytesEm: 130| 617k| { 131| 617k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 617k| } _ZN12PoolResourceILm128ELm1EE13AllocateChunkEv: 157| 119k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 119k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 119k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 96.5k, False: 22.6k] ------------------ 161| 96.5k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 96.5k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 96.5k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 96.5k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 96.5k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 96.5k| } 165| | 166| 119k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 119k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 119k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 119k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 119k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 119k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 119k| } _ZN12PoolResourceILm128ELm1EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 404k| { 147| 404k| node = new (p) ListNode{node}; 148| 404k| } _ZN12PoolResourceILm128ELm1EE8ListNodeC2EPS1_: 84| 404k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm128ELm1EE8AllocateEmm: 220| 318k| { 221| 318k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 308k, False: 10.5k] ------------------ 222| 308k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 308k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 2.90k, False: 305k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 2.90k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 2.90k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 2.90k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 2.90k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 2.90k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 2.90k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 2.90k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 2.90k| return std::exchange(m_free_lists[num_alignments], next); 232| 2.90k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 305k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 305k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 118k, False: 186k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 118k| AllocateChunk(); 239| 118k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 305k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 305k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 305k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 308k| } 245| | 246| | // Can't use the pool => use operator new() 247| 10.5k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 318k| } _ZN12PoolResourceILm128ELm1EE16IsFreeListUsableEmm: 138| 637k| { 139| 637k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 634k, False: 3.64k] | Branch (139:49): [True: 616k, False: 17.4k] ------------------ 140| 637k| } _ZN12PoolResourceILm128ELm1EE10DeallocateEPvmm: 254| 318k| { 255| 318k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 308k, False: 10.5k] ------------------ 256| 308k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 308k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 308k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 308k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 308k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 308k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 308k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 10.5k| ::operator delete (p, std::align_val_t{alignment}); 265| 10.5k| } 266| 318k| } _ZNK12PoolResourceILm128ELm1EE14ChunkSizeBytesEv: 280| 119k| { 281| 119k| return m_chunk_size_bytes; 282| 119k| } _ZN12PoolResourceILm128ELm1EED2Ev: 207| 522| { 208| 119k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 119k, False: 522] ------------------ 209| 119k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 119k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 119k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 119k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 119k| } 213| 522| } _ZN12PoolResourceILm128ELm2EEC2Em: 184| 493| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 493| { 186| 493| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 493, False: 0] ------------------ 187| 493| AllocateChunk(); 188| 493| } _ZN12PoolResourceILm128ELm2EE17NumElemAlignBytesEm: 130| 439k| { 131| 439k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 439k| } _ZN12PoolResourceILm128ELm2EE13AllocateChunkEv: 157| 95.2k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 95.2k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 95.2k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 89.9k, False: 5.31k] ------------------ 161| 89.9k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 89.9k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 89.9k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 89.9k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 89.9k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 89.9k| } 165| | 166| 95.2k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 95.2k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 95.2k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 95.2k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 95.2k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 95.2k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 95.2k| } _ZN12PoolResourceILm128ELm2EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 309k| { 147| 309k| node = new (p) ListNode{node}; 148| 309k| } _ZN12PoolResourceILm128ELm2EE8ListNodeC2EPS1_: 84| 309k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm128ELm2EE8AllocateEmm: 220| 230k| { 221| 230k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 219k, False: 10.9k] ------------------ 222| 219k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 219k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 2.49k, False: 217k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 2.49k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 2.49k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 2.49k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 2.49k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 2.49k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 2.49k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 2.49k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 2.49k| return std::exchange(m_free_lists[num_alignments], next); 232| 2.49k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 217k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 217k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 94.7k, False: 122k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 94.7k| AllocateChunk(); 239| 94.7k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 217k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 217k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 217k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 219k| } 245| | 246| | // Can't use the pool => use operator new() 247| 10.9k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 230k| } _ZN12PoolResourceILm128ELm2EE16IsFreeListUsableEmm: 138| 461k| { 139| 461k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 456k, False: 4.83k] | Branch (139:49): [True: 439k, False: 17.0k] ------------------ 140| 461k| } _ZN12PoolResourceILm128ELm2EE10DeallocateEPvmm: 254| 230k| { 255| 230k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 219k, False: 10.9k] ------------------ 256| 219k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 219k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 219k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 219k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 219k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 219k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 219k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 10.9k| ::operator delete (p, std::align_val_t{alignment}); 265| 10.9k| } 266| 230k| } _ZNK12PoolResourceILm128ELm2EE14ChunkSizeBytesEv: 280| 95.2k| { 281| 95.2k| return m_chunk_size_bytes; 282| 95.2k| } _ZN12PoolResourceILm128ELm2EED2Ev: 207| 493| { 208| 95.2k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 95.2k, False: 493] ------------------ 209| 95.2k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 95.2k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 95.2k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 95.2k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 95.2k| } 213| 493| } _ZN12PoolResourceILm128ELm4EEC2Em: 184| 389| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 389| { 186| 389| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 389, False: 0] ------------------ 187| 389| AllocateChunk(); 188| 389| } _ZN12PoolResourceILm128ELm4EE17NumElemAlignBytesEm: 130| 263k| { 131| 263k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 263k| } _ZN12PoolResourceILm128ELm4EE13AllocateChunkEv: 157| 65.1k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 65.1k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 65.1k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 62.9k, False: 2.19k] ------------------ 161| 62.9k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 62.9k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 62.9k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 62.9k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 62.9k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 62.9k| } 165| | 166| 65.1k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 65.1k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 65.1k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 65.1k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 65.1k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 65.1k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 65.1k| } _ZN12PoolResourceILm128ELm4EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 194k| { 147| 194k| node = new (p) ListNode{node}; 148| 194k| } _ZN12PoolResourceILm128ELm4EE8ListNodeC2EPS1_: 84| 194k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm128ELm4EE8AllocateEmm: 220| 142k| { 221| 142k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 131k, False: 10.7k] ------------------ 222| 131k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 131k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 1.22k, False: 130k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 1.22k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 1.22k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 1.22k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 1.22k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 1.22k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 1.22k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 1.22k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 1.22k| return std::exchange(m_free_lists[num_alignments], next); 232| 1.22k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 130k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 130k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 64.7k, False: 65.4k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 64.7k| AllocateChunk(); 239| 64.7k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 130k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 130k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 130k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 131k| } 245| | 246| | // Can't use the pool => use operator new() 247| 10.7k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 142k| } _ZN12PoolResourceILm128ELm4EE16IsFreeListUsableEmm: 138| 284k| { 139| 284k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 282k, False: 2.16k] | Branch (139:49): [True: 262k, False: 19.2k] ------------------ 140| 284k| } _ZN12PoolResourceILm128ELm4EE10DeallocateEPvmm: 254| 142k| { 255| 142k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 131k, False: 10.7k] ------------------ 256| 131k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 131k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 131k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 131k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 131k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 131k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 131k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 10.7k| ::operator delete (p, std::align_val_t{alignment}); 265| 10.7k| } 266| 142k| } _ZNK12PoolResourceILm128ELm4EE14ChunkSizeBytesEv: 280| 65.1k| { 281| 65.1k| return m_chunk_size_bytes; 282| 65.1k| } _ZN12PoolResourceILm128ELm4EED2Ev: 207| 389| { 208| 65.1k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 65.1k, False: 389] ------------------ 209| 65.1k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 65.1k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 65.1k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 65.1k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 65.1k| } 213| 389| } _ZN12PoolResourceILm128ELm8EEC2Em: 184| 582| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 582| { 186| 582| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 582, False: 0] ------------------ 187| 582| AllocateChunk(); 188| 582| } _ZN12PoolResourceILm128ELm8EE17NumElemAlignBytesEm: 130| 547k| { 131| 547k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 547k| } _ZN12PoolResourceILm128ELm8EE13AllocateChunkEv: 157| 92.1k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 92.1k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 92.1k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 89.4k, False: 2.70k] ------------------ 161| 89.4k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 89.4k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 89.4k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 89.4k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 89.4k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 89.4k| } 165| | 166| 92.1k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 92.1k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 92.1k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 92.1k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 92.1k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 92.1k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 92.1k| } _ZN12PoolResourceILm128ELm8EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 363k| { 147| 363k| node = new (p) ListNode{node}; 148| 363k| } _ZN12PoolResourceILm128ELm8EE8ListNodeC2EPS1_: 84| 363k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm128ELm8EE8AllocateEmm: 220| 279k| { 221| 279k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 273k, False: 5.80k] ------------------ 222| 273k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 273k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 2.45k, False: 271k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 2.45k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 2.45k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 2.45k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 2.45k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 2.45k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 2.45k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 2.45k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 2.45k| return std::exchange(m_free_lists[num_alignments], next); 232| 2.45k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 271k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 271k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 91.5k, False: 179k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 91.5k| AllocateChunk(); 239| 91.5k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 271k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 271k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 271k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 273k| } 245| | 246| | // Can't use the pool => use operator new() 247| 5.80k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 279k| } _ZN12PoolResourceILm128ELm8EE16IsFreeListUsableEmm: 138| 558k| { 139| 558k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 554k, False: 3.97k] | Branch (139:49): [True: 547k, False: 7.63k] ------------------ 140| 558k| } _ZN12PoolResourceILm128ELm8EE10DeallocateEPvmm: 254| 279k| { 255| 279k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 273k, False: 5.80k] ------------------ 256| 273k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 273k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 273k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 273k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 273k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 273k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 273k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 5.80k| ::operator delete (p, std::align_val_t{alignment}); 265| 5.80k| } 266| 279k| } _ZNK12PoolResourceILm128ELm8EE14ChunkSizeBytesEv: 280| 92.1k| { 281| 92.1k| return m_chunk_size_bytes; 282| 92.1k| } _ZN12PoolResourceILm128ELm8EED2Ev: 207| 582| { 208| 92.1k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 92.1k, False: 582] ------------------ 209| 92.1k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 92.1k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 92.1k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 92.1k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 92.1k| } 213| 582| } _ZN12PoolResourceILm8ELm8EEC2Em: 184| 395| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 395| { 186| 395| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 395, False: 0] ------------------ 187| 395| AllocateChunk(); 188| 395| } _ZN12PoolResourceILm8ELm8EE17NumElemAlignBytesEm: 130| 425k| { 131| 425k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 425k| } _ZN12PoolResourceILm8ELm8EE13AllocateChunkEv: 157| 50.2k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 50.2k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 50.2k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 0, False: 50.2k] ------------------ 161| 0| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 0|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 0| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 0| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 0|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 0| } 165| | 166| 50.2k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 50.2k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 50.2k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 50.2k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 50.2k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 50.2k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 50.2k| } _ZN12PoolResourceILm8ELm8EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 212k| { 147| 212k| node = new (p) ListNode{node}; 148| 212k| } _ZN12PoolResourceILm8ELm8EE8ListNodeC2EPS1_: 84| 212k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm8ELm8EE8AllocateEmm: 220| 251k| { 221| 251k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 212k, False: 38.4k] ------------------ 222| 212k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 212k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 1.07k, False: 211k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 1.07k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 1.07k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 1.07k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 1.07k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 1.07k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 1.07k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 1.07k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 1.07k| return std::exchange(m_free_lists[num_alignments], next); 232| 1.07k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 211k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 211k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 49.8k, False: 161k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 49.8k| AllocateChunk(); 239| 49.8k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 211k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 211k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 211k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 212k| } 245| | 246| | // Can't use the pool => use operator new() 247| 38.4k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 251k| } _ZN12PoolResourceILm8ELm8EE16IsFreeListUsableEmm: 138| 502k| { 139| 502k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 497k, False: 4.44k] | Branch (139:49): [True: 425k, False: 72.4k] ------------------ 140| 502k| } _ZN12PoolResourceILm8ELm8EE10DeallocateEPvmm: 254| 251k| { 255| 251k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 212k, False: 38.4k] ------------------ 256| 212k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 212k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 212k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 212k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 212k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 212k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 212k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 38.4k| ::operator delete (p, std::align_val_t{alignment}); 265| 38.4k| } 266| 251k| } _ZNK12PoolResourceILm8ELm8EE14ChunkSizeBytesEv: 280| 50.2k| { 281| 50.2k| return m_chunk_size_bytes; 282| 50.2k| } _ZN12PoolResourceILm8ELm8EED2Ev: 207| 395| { 208| 50.2k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 50.2k, False: 395] ------------------ 209| 50.2k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 50.2k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 50.2k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 50.2k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 50.2k| } 213| 395| } _ZN12PoolResourceILm16ELm16EEC2Em: 184| 592| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 592| { 186| 592| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 592, False: 0] ------------------ 187| 592| AllocateChunk(); 188| 592| } _ZN12PoolResourceILm16ELm16EE17NumElemAlignBytesEm: 130| 1.00M| { 131| 1.00M| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 1.00M| } _ZN12PoolResourceILm16ELm16EE13AllocateChunkEv: 157| 51.9k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 51.9k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 51.9k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 0, False: 51.9k] ------------------ 161| 0| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 0|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 0| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 0| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 0|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 0| } 165| | 166| 51.9k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 51.9k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 51.9k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 51.9k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 51.9k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 51.9k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 51.9k| } _ZN12PoolResourceILm16ELm16EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 501k| { 147| 501k| node = new (p) ListNode{node}; 148| 501k| } _ZN12PoolResourceILm16ELm16EE8ListNodeC2EPS1_: 84| 501k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm16ELm16EE8AllocateEmm: 220| 519k| { 221| 519k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 501k, False: 18.1k] ------------------ 222| 501k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 501k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 2.00k, False: 499k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 2.00k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 2.00k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 2.00k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 2.00k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 2.00k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 2.00k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 2.00k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 2.00k| return std::exchange(m_free_lists[num_alignments], next); 232| 2.00k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 499k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 499k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 51.3k, False: 447k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 51.3k| AllocateChunk(); 239| 51.3k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 499k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 499k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 499k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 501k| } 245| | 246| | // Can't use the pool => use operator new() 247| 18.1k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 519k| } _ZN12PoolResourceILm16ELm16EE16IsFreeListUsableEmm: 138| 1.03M| { 139| 1.03M| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 1.03M, False: 5.25k] | Branch (139:49): [True: 1.00M, False: 31.0k] ------------------ 140| 1.03M| } _ZN12PoolResourceILm16ELm16EE10DeallocateEPvmm: 254| 519k| { 255| 519k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 501k, False: 18.1k] ------------------ 256| 501k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 501k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 501k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 501k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 501k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 501k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 501k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 18.1k| ::operator delete (p, std::align_val_t{alignment}); 265| 18.1k| } 266| 519k| } _ZNK12PoolResourceILm16ELm16EE14ChunkSizeBytesEv: 280| 51.9k| { 281| 51.9k| return m_chunk_size_bytes; 282| 51.9k| } _ZN12PoolResourceILm16ELm16EED2Ev: 207| 592| { 208| 51.9k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 51.9k, False: 592] ------------------ 209| 51.9k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 51.9k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 51.9k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 51.9k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 51.9k| } 213| 592| } _ZN12PoolResourceILm256ELm16EEC2Em: 184| 429| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 429| { 186| 429| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 429, False: 0] ------------------ 187| 429| AllocateChunk(); 188| 429| } _ZN12PoolResourceILm256ELm16EE17NumElemAlignBytesEm: 130| 194k| { 131| 194k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 194k| } _ZN12PoolResourceILm256ELm16EE13AllocateChunkEv: 157| 37.3k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 37.3k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 37.3k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 32.7k, False: 4.60k] ------------------ 161| 32.7k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 32.7k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 32.7k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 32.7k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 32.7k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 32.7k| } 165| | 166| 37.3k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 37.3k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 37.3k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 37.3k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 37.3k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 37.3k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 37.3k| } _ZN12PoolResourceILm256ELm16EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 129k| { 147| 129k| node = new (p) ListNode{node}; 148| 129k| } _ZN12PoolResourceILm256ELm16EE8ListNodeC2EPS1_: 84| 129k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm256ELm16EE8AllocateEmm: 220| 101k| { 221| 101k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 97.2k, False: 4.56k] ------------------ 222| 97.2k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 97.2k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 1.05k, False: 96.1k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 1.05k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 1.05k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 1.05k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 1.05k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 1.05k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 1.05k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 1.05k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 1.05k| return std::exchange(m_free_lists[num_alignments], next); 232| 1.05k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 96.1k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 96.1k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 36.9k, False: 59.2k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 36.9k| AllocateChunk(); 239| 36.9k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 96.1k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 96.1k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 96.1k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 97.2k| } 245| | 246| | // Can't use the pool => use operator new() 247| 4.56k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 101k| } _ZN12PoolResourceILm256ELm16EE16IsFreeListUsableEmm: 138| 203k| { 139| 203k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 201k, False: 1.59k] | Branch (139:49): [True: 194k, False: 7.53k] ------------------ 140| 203k| } _ZN12PoolResourceILm256ELm16EE10DeallocateEPvmm: 254| 101k| { 255| 101k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 97.2k, False: 4.56k] ------------------ 256| 97.2k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 97.2k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 97.2k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 97.2k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 97.2k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 97.2k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 97.2k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 4.56k| ::operator delete (p, std::align_val_t{alignment}); 265| 4.56k| } 266| 101k| } _ZNK12PoolResourceILm256ELm16EE14ChunkSizeBytesEv: 280| 37.3k| { 281| 37.3k| return m_chunk_size_bytes; 282| 37.3k| } _ZN12PoolResourceILm256ELm16EED2Ev: 207| 429| { 208| 37.3k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 37.3k, False: 429] ------------------ 209| 37.3k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 37.3k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 37.3k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 37.3k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 37.3k| } 213| 429| } _ZN12PoolResourceILm256ELm64EEC2Em: 184| 551| : m_chunk_size_bytes(NumElemAlignBytes(chunk_size_bytes) * ELEM_ALIGN_BYTES) 185| 551| { 186| 551| assert(m_chunk_size_bytes >= MAX_BLOCK_SIZE_BYTES); ------------------ | Branch (186:9): [True: 551, False: 0] ------------------ 187| 551| AllocateChunk(); 188| 551| } _ZN12PoolResourceILm256ELm64EE17NumElemAlignBytesEm: 130| 844k| { 131| 844k| return CeilDiv(bytes, ELEM_ALIGN_BYTES) + (bytes == 0); 132| 844k| } _ZN12PoolResourceILm256ELm64EE13AllocateChunkEv: 157| 147k| { 158| | // if there is still any available memory left, put it into the freelist. 159| 147k| size_t remaining_available_bytes = m_available_memory_end - m_available_memory_it; 160| 147k| if (0 != remaining_available_bytes) { ------------------ | Branch (160:13): [True: 118k, False: 28.5k] ------------------ 161| 118k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 144| 118k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 162| 118k| PlacementAddToList(m_available_memory_it, m_free_lists[remaining_available_bytes / ELEM_ALIGN_BYTES]); 163| 118k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, sizeof(ListNode)); ------------------ | | 143| 118k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 164| 118k| } 165| | 166| 147k| void* storage = ::operator new (m_chunk_size_bytes, std::align_val_t{ELEM_ALIGN_BYTES}); 167| 147k| m_available_memory_it = new (storage) std::byte[m_chunk_size_bytes]; 168| 147k| m_available_memory_end = m_available_memory_it + m_chunk_size_bytes; 169| 147k| ASAN_POISON_MEMORY_REGION(m_available_memory_it, m_chunk_size_bytes); ------------------ | | 143| 147k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 170| 147k| m_allocated_chunks.emplace_back(m_available_memory_it); 171| 147k| } _ZN12PoolResourceILm256ELm64EE18PlacementAddToListEPvRPNS0_8ListNodeE: 146| 540k| { 147| 540k| node = new (p) ListNode{node}; 148| 540k| } _ZN12PoolResourceILm256ELm64EE8ListNodeC2EPS1_: 84| 540k| explicit ListNode(ListNode* next) : m_next(next) {} _ZN12PoolResourceILm256ELm64EE8AllocateEmm: 220| 430k| { 221| 430k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (221:13): [True: 422k, False: 8.19k] ------------------ 222| 422k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 223| 422k| if (nullptr != m_free_lists[num_alignments]) { ------------------ | Branch (223:17): [True: 2.51k, False: 419k] ------------------ 224| | // we've already got data in the pool's freelist, unlink one element and return the pointer 225| | // to the unlinked memory. Since FreeList is trivially destructible we can just treat it as 226| | // uninitialized memory. 227| 2.51k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 144| 2.51k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 228| 2.51k| auto* next{m_free_lists[num_alignments]->m_next}; 229| 2.51k| ASAN_POISON_MEMORY_REGION(m_free_lists[num_alignments], sizeof(ListNode)); ------------------ | | 143| 2.51k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 230| 2.51k| ASAN_UNPOISON_MEMORY_REGION(m_free_lists[num_alignments], bytes); ------------------ | | 144| 2.51k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 231| 2.51k| return std::exchange(m_free_lists[num_alignments], next); 232| 2.51k| } 233| | 234| | // freelist is empty: get one allocation from allocated chunk memory. 235| 419k| const std::ptrdiff_t round_bytes = static_cast(num_alignments * ELEM_ALIGN_BYTES); 236| 419k| if (round_bytes > m_available_memory_end - m_available_memory_it) { ------------------ | Branch (236:17): [True: 146k, False: 272k] ------------------ 237| | // slow path, only happens when a new chunk needs to be allocated 238| 146k| AllocateChunk(); 239| 146k| } 240| | 241| | // Make sure we use the right amount of bytes for that freelist (might be rounded up), 242| 419k| ASAN_UNPOISON_MEMORY_REGION(m_available_memory_it, round_bytes); ------------------ | | 144| 419k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 243| 419k| return std::exchange(m_available_memory_it, m_available_memory_it + round_bytes); 244| 422k| } 245| | 246| | // Can't use the pool => use operator new() 247| 8.19k| return ::operator new (bytes, std::align_val_t{alignment}); 248| 430k| } _ZN12PoolResourceILm256ELm64EE16IsFreeListUsableEmm: 138| 860k| { 139| 860k| return alignment <= ELEM_ALIGN_BYTES && bytes <= MAX_BLOCK_SIZE_BYTES; ------------------ | Branch (139:16): [True: 857k, False: 2.61k] | Branch (139:49): [True: 844k, False: 13.7k] ------------------ 140| 860k| } _ZN12PoolResourceILm256ELm64EE10DeallocateEPvmm: 254| 430k| { 255| 430k| if (IsFreeListUsable(bytes, alignment)) { ------------------ | Branch (255:13): [True: 422k, False: 8.19k] ------------------ 256| 422k| const std::size_t num_alignments = NumElemAlignBytes(bytes); 257| | // put the memory block into the linked list. We can placement construct the FreeList 258| | // into the memory since we can be sure the alignment is correct. 259| 422k| ASAN_UNPOISON_MEMORY_REGION(p, sizeof(ListNode)); ------------------ | | 144| 422k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 260| 422k| PlacementAddToList(p, m_free_lists[num_alignments]); 261| 422k| ASAN_POISON_MEMORY_REGION(p, std::max(bytes, sizeof(ListNode))); ------------------ | | 143| 422k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 262| 422k| } else { 263| | // Can't use the pool => forward deallocation to ::operator delete(). 264| 8.19k| ::operator delete (p, std::align_val_t{alignment}); 265| 8.19k| } 266| 430k| } _ZNK12PoolResourceILm256ELm64EE14ChunkSizeBytesEv: 280| 147k| { 281| 147k| return m_chunk_size_bytes; 282| 147k| } _ZN12PoolResourceILm256ELm64EED2Ev: 207| 551| { 208| 147k| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (208:31): [True: 147k, False: 551] ------------------ 209| 147k| std::destroy(chunk, chunk + m_chunk_size_bytes); 210| 147k| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 211| 147k| ASAN_UNPOISON_MEMORY_REGION(chunk, m_chunk_size_bytes); ------------------ | | 144| 147k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 212| 147k| } 213| 551| } 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| } _ZN18FuzzedDataProviderC2EPKhm: 37| 3.95k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 2.57M|inline bool FuzzedDataProvider::ConsumeBool() { 290| 2.57M| return 1 & ConsumeIntegral(); 291| 2.57M|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 2.57M|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.57M| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.57M| std::numeric_limits::max()); 198| 2.57M|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 2.57M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.57M| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.57M| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.57M| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.57M] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.57M| uint64_t range = static_cast(max) - static_cast(min); 214| 2.57M| uint64_t result = 0; 215| 2.57M| size_t offset = 0; 216| | 217| 5.15M| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 2.57M, False: 2.57M] | Branch (217:43): [True: 2.57M, False: 0] ------------------ 218| 2.57M| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 2.57M, False: 2.48k] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 2.57M| --remaining_bytes_; 226| 2.57M| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 2.57M| offset += CHAR_BIT; 228| 2.57M| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.57M| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.57M, False: 0] ------------------ 232| 2.57M| result = result % (range + 1); 233| | 234| 2.57M| return static_cast(static_cast(min) + result); 235| 2.57M|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 11.6M|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 11.6M| static_assert(std::is_integral_v, "An integral type is required."); 207| 11.6M| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 11.6M| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 11.6M] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 11.6M| uint64_t range = static_cast(max) - static_cast(min); 214| 11.6M| uint64_t result = 0; 215| 11.6M| size_t offset = 0; 216| | 217| 20.8M| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 20.8M, False: 0] | Branch (217:43): [True: 10.9M, False: 9.93M] ------------------ 218| 10.9M| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 9.20M, False: 1.73M] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 9.20M| --remaining_bytes_; 226| 9.20M| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 9.20M| offset += CHAR_BIT; 228| 9.20M| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 11.6M| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 11.6M, False: 0] ------------------ 232| 11.6M| result = result % (range + 1); 233| | 234| 11.6M| return static_cast(static_cast(min) + result); 235| 11.6M|} LLVMFuzzerTestOneInput: 213| 3.95k|{ 214| 3.95k| test_one_input({data, size}); 215| 3.95k| return 0; 216| 3.95k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 3.95k|{ 85| 3.95k| CheckGlobals check{}; 86| 3.95k| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 3.95k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 3.95k|} _Z25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 133| 3.95k|{ 134| 3.95k| FuzzedDataProvider provider(buffer.data(), buffer.size()); 135| 3.95k| CallOneOf( 136| 3.95k| provider, 137| 3.95k| [&] { PoolResourceFuzzer<128, 1>{provider}.Fuzz(); }, 138| 3.95k| [&] { PoolResourceFuzzer<128, 2>{provider}.Fuzz(); }, 139| 3.95k| [&] { PoolResourceFuzzer<128, 4>{provider}.Fuzz(); }, 140| 3.95k| [&] { PoolResourceFuzzer<128, 8>{provider}.Fuzz(); }, 141| | 142| 3.95k| [&] { PoolResourceFuzzer<8, 8>{provider}.Fuzz(); }, 143| 3.95k| [&] { PoolResourceFuzzer<16, 16>{provider}.Fuzz(); }, 144| | 145| 3.95k| [&] { PoolResourceFuzzer<256, alignof(max_align_t)>{provider}.Fuzz(); }, 146| 3.95k| [&] { PoolResourceFuzzer<256, 64>{provider}.Fuzz(); }); 147| 3.95k|} poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 137| 522| [&] { PoolResourceFuzzer<128, 1>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EEC2ER18FuzzedDataProvider: 40| 522| : m_provider{provider}, 41| 522| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 522| { 43| 522| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEv: 118| 522| { 119| 344k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 345k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 344k, False: 520] | | | Branch (23:49): [True: 344k, False: 2] | | ------------------ ------------------ 120| 344k| CallOneOf( 121| 344k| m_provider, 122| 344k| [&] { Allocate(); }, 123| 344k| [&] { Deallocate(); }); 124| 344k| } 125| 522| Clear(); 126| 522| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEvENKUlvE_clEv: 122| 319k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE8AllocateEv: 64| 319k| { 65| 319k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 194, False: 318k] ------------------ 66| 318k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 318k| size_t alignment = size_t{1} << alignment_bits; 68| 318k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 318k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 318k| Allocate(size, alignment); 71| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE8AllocateEmm: 46| 318k| { 47| 318k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 318k, False: 0] ------------------ 48| 318k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 318k, False: 0] ------------------ 49| 318k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 318k, False: 0] ------------------ 50| 318k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 318k, False: 0] ------------------ 51| | 52| 318k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 318k| m_total_allocated += size; 54| | 55| 318k| auto ptr_val = reinterpret_cast(span.data()); 56| 318k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 318k, False: 0] ------------------ 57| | 58| 318k| uint64_t seed = m_sequence++; 59| 318k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE17RandomContentFillERNS1_5EntryE: 74| 318k| { 75| 318k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 318k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEvENKUlvE0_clEv: 123| 25.7k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE10DeallocateEv: 95| 339k| { 96| 339k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 20.1k, False: 318k] ------------------ 97| 20.1k| return; 98| 20.1k| } 99| | 100| 318k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 318k| Deallocate(m_entries[idx]); 102| 318k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 317k, False: 1.57k] ------------------ 103| 317k| m_entries[idx] = std::move(m_entries.back()); 104| 317k| } 105| 318k| m_entries.pop_back(); 106| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE10DeallocateERKNS1_5EntryE: 86| 318k| { 87| 318k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 318k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 318k, False: 0] ------------------ 89| 318k| RandomContentCheck(entry); 90| 318k| m_total_allocated -= entry.span.size(); 91| 318k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE18RandomContentCheckERKNS1_5EntryE: 79| 318k| { 80| 318k| std::vector expect(entry.span.size()); 81| 318k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 318k, False: 0] ------------------ 83| 318k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE5ClearEv: 109| 522| { 110| 313k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 313k, False: 522] ------------------ 111| 313k| Deallocate(); 112| 313k| } 113| | 114| 522| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 522| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv: 138| 493| [&] { PoolResourceFuzzer<128, 2>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EEC2ER18FuzzedDataProvider: 40| 493| : m_provider{provider}, 41| 493| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 493| { 43| 493| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEv: 118| 493| { 119| 304k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 304k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 304k, False: 484] | | | Branch (23:49): [True: 304k, False: 9] | | ------------------ ------------------ 120| 304k| CallOneOf( 121| 304k| m_provider, 122| 304k| [&] { Allocate(); }, 123| 304k| [&] { Deallocate(); }); 124| 304k| } 125| 493| Clear(); 126| 493| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEvENKUlvE_clEv: 122| 230k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE8AllocateEv: 64| 230k| { 65| 230k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 242, False: 230k] ------------------ 66| 230k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 230k| size_t alignment = size_t{1} << alignment_bits; 68| 230k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 230k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 230k| Allocate(size, alignment); 71| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE8AllocateEmm: 46| 230k| { 47| 230k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 230k, False: 0] ------------------ 48| 230k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 230k, False: 0] ------------------ 49| 230k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 230k, False: 0] ------------------ 50| 230k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 230k, False: 0] ------------------ 51| | 52| 230k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 230k| m_total_allocated += size; 54| | 55| 230k| auto ptr_val = reinterpret_cast(span.data()); 56| 230k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 230k, False: 0] ------------------ 57| | 58| 230k| uint64_t seed = m_sequence++; 59| 230k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE17RandomContentFillERNS1_5EntryE: 74| 230k| { 75| 230k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 230k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEvENKUlvE0_clEv: 123| 73.4k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE10DeallocateEv: 95| 300k| { 96| 300k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 70.3k, False: 230k] ------------------ 97| 70.3k| return; 98| 70.3k| } 99| | 100| 230k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 230k| Deallocate(m_entries[idx]); 102| 230k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 229k, False: 1.49k] ------------------ 103| 229k| m_entries[idx] = std::move(m_entries.back()); 104| 229k| } 105| 230k| m_entries.pop_back(); 106| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE10DeallocateERKNS1_5EntryE: 86| 230k| { 87| 230k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 230k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 230k, False: 0] ------------------ 89| 230k| RandomContentCheck(entry); 90| 230k| m_total_allocated -= entry.span.size(); 91| 230k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE18RandomContentCheckERKNS1_5EntryE: 79| 230k| { 80| 230k| std::vector expect(entry.span.size()); 81| 230k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 230k, False: 0] ------------------ 83| 230k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE5ClearEv: 109| 493| { 110| 227k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 227k, False: 493] ------------------ 111| 227k| Deallocate(); 112| 227k| } 113| | 114| 493| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 493| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv: 139| 389| [&] { PoolResourceFuzzer<128, 4>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EEC2ER18FuzzedDataProvider: 40| 389| : m_provider{provider}, 41| 389| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 389| { 43| 389| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEv: 118| 389| { 119| 164k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 165k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 164k, False: 386] | | | Branch (23:49): [True: 164k, False: 3] | | ------------------ ------------------ 120| 164k| CallOneOf( 121| 164k| m_provider, 122| 164k| [&] { Allocate(); }, 123| 164k| [&] { Deallocate(); }); 124| 164k| } 125| 389| Clear(); 126| 389| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEvENKUlvE_clEv: 122| 142k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE8AllocateEv: 64| 142k| { 65| 142k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 200, False: 142k] ------------------ 66| 142k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 142k| size_t alignment = size_t{1} << alignment_bits; 68| 142k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 142k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 142k| Allocate(size, alignment); 71| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE8AllocateEmm: 46| 142k| { 47| 142k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 142k, False: 0] ------------------ 48| 142k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 142k, False: 0] ------------------ 49| 142k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 142k, False: 0] ------------------ 50| 142k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 142k, False: 0] ------------------ 51| | 52| 142k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 142k| m_total_allocated += size; 54| | 55| 142k| auto ptr_val = reinterpret_cast(span.data()); 56| 142k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 142k, False: 0] ------------------ 57| | 58| 142k| uint64_t seed = m_sequence++; 59| 142k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE17RandomContentFillERNS1_5EntryE: 74| 142k| { 75| 142k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 142k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEvENKUlvE0_clEv: 123| 22.4k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE10DeallocateEv: 95| 162k| { 96| 162k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 20.6k, False: 142k] ------------------ 97| 20.6k| return; 98| 20.6k| } 99| | 100| 142k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 142k| Deallocate(m_entries[idx]); 102| 142k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 141k, False: 1.03k] ------------------ 103| 141k| m_entries[idx] = std::move(m_entries.back()); 104| 141k| } 105| 142k| m_entries.pop_back(); 106| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE10DeallocateERKNS1_5EntryE: 86| 142k| { 87| 142k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 142k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 142k, False: 0] ------------------ 89| 142k| RandomContentCheck(entry); 90| 142k| m_total_allocated -= entry.span.size(); 91| 142k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE18RandomContentCheckERKNS1_5EntryE: 79| 142k| { 80| 142k| std::vector expect(entry.span.size()); 81| 142k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 142k, False: 0] ------------------ 83| 142k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE5ClearEv: 109| 389| { 110| 140k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 140k, False: 389] ------------------ 111| 140k| Deallocate(); 112| 140k| } 113| | 114| 389| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 389| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv: 140| 582| [&] { PoolResourceFuzzer<128, 8>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EEC2ER18FuzzedDataProvider: 40| 582| : m_provider{provider}, 41| 582| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 582| { 43| 582| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEv: 118| 582| { 119| 315k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 315k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 315k, False: 578] | | | Branch (23:49): [True: 315k, False: 4] | | ------------------ ------------------ 120| 315k| CallOneOf( 121| 315k| m_provider, 122| 315k| [&] { Allocate(); }, 123| 315k| [&] { Deallocate(); }); 124| 315k| } 125| 582| Clear(); 126| 582| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEvENKUlvE_clEv: 122| 279k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE8AllocateEv: 64| 279k| { 65| 279k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 195, False: 279k] ------------------ 66| 279k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 279k| size_t alignment = size_t{1} << alignment_bits; 68| 279k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 279k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 279k| Allocate(size, alignment); 71| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE8AllocateEmm: 46| 279k| { 47| 279k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 279k, False: 0] ------------------ 48| 279k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 279k, False: 0] ------------------ 49| 279k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 279k, False: 0] ------------------ 50| 279k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 279k, False: 0] ------------------ 51| | 52| 279k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 279k| m_total_allocated += size; 54| | 55| 279k| auto ptr_val = reinterpret_cast(span.data()); 56| 279k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 279k, False: 0] ------------------ 57| | 58| 279k| uint64_t seed = m_sequence++; 59| 279k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE17RandomContentFillERNS1_5EntryE: 74| 279k| { 75| 279k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 279k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEvENKUlvE0_clEv: 123| 35.7k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE10DeallocateEv: 95| 311k| { 96| 311k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 32.0k, False: 279k] ------------------ 97| 32.0k| return; 98| 32.0k| } 99| | 100| 279k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 279k| Deallocate(m_entries[idx]); 102| 279k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 277k, False: 1.55k] ------------------ 103| 277k| m_entries[idx] = std::move(m_entries.back()); 104| 277k| } 105| 279k| m_entries.pop_back(); 106| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE10DeallocateERKNS1_5EntryE: 86| 279k| { 87| 279k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 279k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 279k, False: 0] ------------------ 89| 279k| RandomContentCheck(entry); 90| 279k| m_total_allocated -= entry.span.size(); 91| 279k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE18RandomContentCheckERKNS1_5EntryE: 79| 279k| { 80| 279k| std::vector expect(entry.span.size()); 81| 279k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 279k, False: 0] ------------------ 83| 279k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE5ClearEv: 109| 582| { 110| 276k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 275k, False: 582] ------------------ 111| 275k| Deallocate(); 112| 275k| } 113| | 114| 582| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 582| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv: 142| 395| [&] { PoolResourceFuzzer<8, 8>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EEC2ER18FuzzedDataProvider: 40| 395| : m_provider{provider}, 41| 395| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 395| { 43| 395| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEv: 118| 395| { 119| 266k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 266k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 266k, False: 394] | | | Branch (23:49): [True: 266k, False: 1] | | ------------------ ------------------ 120| 266k| CallOneOf( 121| 266k| m_provider, 122| 266k| [&] { Allocate(); }, 123| 266k| [&] { Deallocate(); }); 124| 266k| } 125| 395| Clear(); 126| 395| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEvENKUlvE_clEv: 122| 251k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE8AllocateEv: 64| 251k| { 65| 251k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 195, False: 251k] ------------------ 66| 251k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 251k| size_t alignment = size_t{1} << alignment_bits; 68| 251k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 251k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 251k| Allocate(size, alignment); 71| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE8AllocateEmm: 46| 251k| { 47| 251k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 251k, False: 0] ------------------ 48| 251k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 251k, False: 0] ------------------ 49| 251k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 251k, False: 0] ------------------ 50| 251k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 251k, False: 0] ------------------ 51| | 52| 251k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 251k| m_total_allocated += size; 54| | 55| 251k| auto ptr_val = reinterpret_cast(span.data()); 56| 251k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 251k, False: 0] ------------------ 57| | 58| 251k| uint64_t seed = m_sequence++; 59| 251k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE17RandomContentFillERNS1_5EntryE: 74| 251k| { 75| 251k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 251k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEvENKUlvE0_clEv: 123| 15.1k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE10DeallocateEv: 95| 264k| { 96| 264k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 13.0k, False: 251k] ------------------ 97| 13.0k| return; 98| 13.0k| } 99| | 100| 251k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 251k| Deallocate(m_entries[idx]); 102| 251k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 250k, False: 1.13k] ------------------ 103| 250k| m_entries[idx] = std::move(m_entries.back()); 104| 250k| } 105| 251k| m_entries.pop_back(); 106| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE10DeallocateERKNS1_5EntryE: 86| 251k| { 87| 251k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 251k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 251k, False: 0] ------------------ 89| 251k| RandomContentCheck(entry); 90| 251k| m_total_allocated -= entry.span.size(); 91| 251k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE18RandomContentCheckERKNS1_5EntryE: 79| 251k| { 80| 251k| std::vector expect(entry.span.size()); 81| 251k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 251k, False: 0] ------------------ 83| 251k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE5ClearEv: 109| 395| { 110| 249k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 249k, False: 395] ------------------ 111| 249k| Deallocate(); 112| 249k| } 113| | 114| 395| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 395| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv: 143| 592| [&] { PoolResourceFuzzer<16, 16>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EEC2ER18FuzzedDataProvider: 40| 592| : m_provider{provider}, 41| 592| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 592| { 43| 592| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEv: 118| 592| { 119| 590k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 591k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 590k, False: 585] | | | Branch (23:49): [True: 590k, False: 7] | | ------------------ ------------------ 120| 590k| CallOneOf( 121| 590k| m_provider, 122| 590k| [&] { Allocate(); }, 123| 590k| [&] { Deallocate(); }); 124| 590k| } 125| 592| Clear(); 126| 592| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEvENKUlvE_clEv: 122| 519k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE8AllocateEv: 64| 519k| { 65| 519k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 207, False: 519k] ------------------ 66| 519k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 519k| size_t alignment = size_t{1} << alignment_bits; 68| 519k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 519k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 519k| Allocate(size, alignment); 71| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE8AllocateEmm: 46| 519k| { 47| 519k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 519k, False: 0] ------------------ 48| 519k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 519k, False: 0] ------------------ 49| 519k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 519k, False: 0] ------------------ 50| 519k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 519k, False: 0] ------------------ 51| | 52| 519k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 519k| m_total_allocated += size; 54| | 55| 519k| auto ptr_val = reinterpret_cast(span.data()); 56| 519k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 519k, False: 0] ------------------ 57| | 58| 519k| uint64_t seed = m_sequence++; 59| 519k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE17RandomContentFillERNS1_5EntryE: 74| 519k| { 75| 519k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 519k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEvENKUlvE0_clEv: 123| 71.1k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE10DeallocateEv: 95| 582k| { 96| 582k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 63.7k, False: 519k] ------------------ 97| 63.7k| return; 98| 63.7k| } 99| | 100| 519k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 519k| Deallocate(m_entries[idx]); 102| 519k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 517k, False: 1.31k] ------------------ 103| 517k| m_entries[idx] = std::move(m_entries.back()); 104| 517k| } 105| 519k| m_entries.pop_back(); 106| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE10DeallocateERKNS1_5EntryE: 86| 519k| { 87| 519k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 519k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 519k, False: 0] ------------------ 89| 519k| RandomContentCheck(entry); 90| 519k| m_total_allocated -= entry.span.size(); 91| 519k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE18RandomContentCheckERKNS1_5EntryE: 79| 519k| { 80| 519k| std::vector expect(entry.span.size()); 81| 519k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 519k, False: 0] ------------------ 83| 519k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE5ClearEv: 109| 592| { 110| 512k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 511k, False: 592] ------------------ 111| 511k| Deallocate(); 112| 511k| } 113| | 114| 592| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 592| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv: 145| 429| [&] { PoolResourceFuzzer<256, alignof(max_align_t)>{provider}.Fuzz(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EEC2ER18FuzzedDataProvider: 40| 429| : m_provider{provider}, 41| 429| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 429| { 43| 429| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEv: 118| 429| { 119| 106k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 106k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 106k, False: 429] | | | Branch (23:49): [True: 106k, False: 0] | | ------------------ ------------------ 120| 106k| CallOneOf( 121| 106k| m_provider, 122| 106k| [&] { Allocate(); }, 123| 106k| [&] { Deallocate(); }); 124| 106k| } 125| 429| Clear(); 126| 429| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEvENKUlvE_clEv: 122| 101k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE8AllocateEv: 64| 101k| { 65| 101k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 199, False: 101k] ------------------ 66| 101k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 101k| size_t alignment = size_t{1} << alignment_bits; 68| 101k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 101k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 101k| Allocate(size, alignment); 71| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE8AllocateEmm: 46| 101k| { 47| 101k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 101k, False: 0] ------------------ 48| 101k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 101k, False: 0] ------------------ 49| 101k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 101k, False: 0] ------------------ 50| 101k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 101k, False: 0] ------------------ 51| | 52| 101k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 101k| m_total_allocated += size; 54| | 55| 101k| auto ptr_val = reinterpret_cast(span.data()); 56| 101k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 101k, False: 0] ------------------ 57| | 58| 101k| uint64_t seed = m_sequence++; 59| 101k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE17RandomContentFillERNS1_5EntryE: 74| 101k| { 75| 101k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 101k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEvENKUlvE0_clEv: 123| 4.06k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE10DeallocateEv: 95| 104k| { 96| 104k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 2.74k, False: 101k] ------------------ 97| 2.74k| return; 98| 2.74k| } 99| | 100| 101k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 101k| Deallocate(m_entries[idx]); 102| 101k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 100k, False: 1.07k] ------------------ 103| 100k| m_entries[idx] = std::move(m_entries.back()); 104| 100k| } 105| 101k| m_entries.pop_back(); 106| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE10DeallocateERKNS1_5EntryE: 86| 101k| { 87| 101k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 101k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 101k, False: 0] ------------------ 89| 101k| RandomContentCheck(entry); 90| 101k| m_total_allocated -= entry.span.size(); 91| 101k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE18RandomContentCheckERKNS1_5EntryE: 79| 101k| { 80| 101k| std::vector expect(entry.span.size()); 81| 101k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 101k, False: 0] ------------------ 83| 101k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE5ClearEv: 109| 429| { 110| 100k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 100k, False: 429] ------------------ 111| 100k| Deallocate(); 112| 100k| } 113| | 114| 429| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 429| } poolresource.cpp:_ZZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv: 146| 551| [&] { PoolResourceFuzzer<256, 64>{provider}.Fuzz(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EEC2ER18FuzzedDataProvider: 40| 551| : m_provider{provider}, 41| 551| m_test_resource{provider.ConsumeIntegralInRange(MAX_BLOCK_SIZE_BYTES, 262144)} 42| 551| { 43| 551| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEv: 118| 551| { 119| 480k| LIMITED_WHILE (m_provider.ConsumeBool(), 10000) { ------------------ | | 23| 481k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 480k, False: 546] | | | Branch (23:49): [True: 480k, False: 5] | | ------------------ ------------------ 120| 480k| CallOneOf( 121| 480k| m_provider, 122| 480k| [&] { Allocate(); }, 123| 480k| [&] { Deallocate(); }); 124| 480k| } 125| 551| Clear(); 126| 551| } poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEvENKUlvE_clEv: 122| 430k| [&] { Allocate(); }, poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE8AllocateEv: 64| 430k| { 65| 430k| if (m_total_allocated > 16_MiB) return; ------------------ | Branch (65:13): [True: 194, False: 430k] ------------------ 66| 430k| size_t alignment_bits = m_provider.ConsumeIntegralInRange(0, 7); 67| 430k| size_t alignment = size_t{1} << alignment_bits; 68| 430k| size_t size_bits = m_provider.ConsumeIntegralInRange(0, 16 - alignment_bits); 69| 430k| size_t size = m_provider.ConsumeIntegralInRange(size_t{1} << size_bits, (size_t{1} << (size_bits + 1)) - 1U) << alignment_bits; 70| 430k| Allocate(size, alignment); 71| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE8AllocateEmm: 46| 430k| { 47| 430k| assert(size > 0); // Must allocate at least 1 byte. ------------------ | Branch (47:9): [True: 430k, False: 0] ------------------ 48| 430k| assert(alignment > 0); // Alignment must be at least 1. ------------------ | Branch (48:9): [True: 430k, False: 0] ------------------ 49| 430k| assert((alignment & (alignment - 1)) == 0); // Alignment must be power of 2. ------------------ | Branch (49:9): [True: 430k, False: 0] ------------------ 50| 430k| assert((size & (alignment - 1)) == 0); // Size must be a multiple of alignment. ------------------ | Branch (50:9): [True: 430k, False: 0] ------------------ 51| | 52| 430k| auto span = std::span(static_cast(m_test_resource.Allocate(size, alignment)), size); 53| 430k| m_total_allocated += size; 54| | 55| 430k| auto ptr_val = reinterpret_cast(span.data()); 56| 430k| assert((ptr_val & (alignment - 1)) == 0); ------------------ | Branch (56:9): [True: 430k, False: 0] ------------------ 57| | 58| 430k| uint64_t seed = m_sequence++; 59| 430k| RandomContentFill(m_entries.emplace_back(span, alignment, seed)); 60| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE17RandomContentFillERNS1_5EntryE: 74| 430k| { 75| 430k| InsecureRandomContext(entry.seed).fillrand(entry.span); 76| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE5EntryC2ENSt3__14spanISt4byteLm18446744073709551615EEEmm: 33| 430k| Entry(std::span s, size_t a, uint64_t se) : span(s), alignment(a), seed(se) {} poolresource.cpp:_ZZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEvENKUlvE0_clEv: 123| 50.0k| [&] { Deallocate(); }); poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE10DeallocateEv: 95| 475k| { 96| 475k| if (m_entries.empty()) { ------------------ | Branch (96:13): [True: 45.5k, False: 430k] ------------------ 97| 45.5k| return; 98| 45.5k| } 99| | 100| 430k| size_t idx = m_provider.ConsumeIntegralInRange(0, m_entries.size() - 1); 101| 430k| Deallocate(m_entries[idx]); 102| 430k| if (idx != m_entries.size() - 1) { ------------------ | Branch (102:13): [True: 428k, False: 1.41k] ------------------ 103| 428k| m_entries[idx] = std::move(m_entries.back()); 104| 428k| } 105| 430k| m_entries.pop_back(); 106| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE10DeallocateERKNS1_5EntryE: 86| 430k| { 87| 430k| auto ptr_val = reinterpret_cast(entry.span.data()); 88| 430k| assert((ptr_val & (entry.alignment - 1)) == 0); ------------------ | Branch (88:9): [True: 430k, False: 0] ------------------ 89| 430k| RandomContentCheck(entry); 90| 430k| m_total_allocated -= entry.span.size(); 91| 430k| m_test_resource.Deallocate(entry.span.data(), entry.span.size(), entry.alignment); 92| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE18RandomContentCheckERKNS1_5EntryE: 79| 430k| { 80| 430k| std::vector expect(entry.span.size()); 81| 430k| InsecureRandomContext(entry.seed).fillrand(expect); 82| | assert(std::ranges::equal(entry.span, expect)); ------------------ | Branch (82:9): [True: 430k, False: 0] ------------------ 83| 430k| } poolresource.cpp:_ZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE5ClearEv: 109| 551| { 110| 426k| while (!m_entries.empty()) { ------------------ | Branch (110:16): [True: 425k, False: 551] ------------------ 111| 425k| Deallocate(); 112| 425k| } 113| | 114| 551| PoolResourceTester::CheckAllDataAccountedFor(m_test_resource); 115| 551| } poolresource.cpp:_Z9CallOneOfIJZ25pool_resource_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z25pool_resource_fuzz_targetS3_E3$_1Z25pool_resource_fuzz_targetS3_E3$_2Z25pool_resource_fuzz_targetS3_E3$_3Z25pool_resource_fuzz_targetS3_E3$_4Z25pool_resource_fuzz_targetS3_E3$_5Z25pool_resource_fuzz_targetS3_E3$_6Z25pool_resource_fuzz_targetS3_E3$_7EEmR18FuzzedDataProviderDpT_: 38| 3.95k|{ 39| 3.95k| constexpr size_t call_size{sizeof...(callables)}; 40| 3.95k| static_assert(call_size >= 1); 41| 3.95k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 3.95k| size_t i{0}; 44| 31.6k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 522, False: 3.43k] | Branch (44:7): [True: 493, False: 3.46k] | Branch (44:7): [True: 389, False: 3.56k] | Branch (44:7): [True: 582, False: 3.37k] | Branch (44:7): [True: 395, False: 3.55k] | Branch (44:7): [True: 592, False: 3.36k] | Branch (44:7): [True: 429, False: 3.52k] | Branch (44:7): [True: 551, False: 3.40k] ------------------ 45| 3.95k| return call_size; 46| 3.95k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm1EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 344k|{ 39| 344k| constexpr size_t call_size{sizeof...(callables)}; 40| 344k| static_assert(call_size >= 1); 41| 344k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 344k| size_t i{0}; 44| 689k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 319k, False: 25.7k] | Branch (44:7): [True: 25.7k, False: 319k] ------------------ 45| 344k| return call_size; 46| 344k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm2EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 304k|{ 39| 304k| constexpr size_t call_size{sizeof...(callables)}; 40| 304k| static_assert(call_size >= 1); 41| 304k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 304k| size_t i{0}; 44| 608k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 230k, False: 73.4k] | Branch (44:7): [True: 73.4k, False: 230k] ------------------ 45| 304k| return call_size; 46| 304k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm4EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 164k|{ 39| 164k| constexpr size_t call_size{sizeof...(callables)}; 40| 164k| static_assert(call_size >= 1); 41| 164k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 164k| size_t i{0}; 44| 329k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 142k, False: 22.4k] | Branch (44:7): [True: 22.4k, False: 142k] ------------------ 45| 164k| return call_size; 46| 164k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm128ELm8EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 315k|{ 39| 315k| constexpr size_t call_size{sizeof...(callables)}; 40| 315k| static_assert(call_size >= 1); 41| 315k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 315k| size_t i{0}; 44| 630k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 279k, False: 35.7k] | Branch (44:7): [True: 35.7k, False: 279k] ------------------ 45| 315k| return call_size; 46| 315k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm8ELm8EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 266k|{ 39| 266k| constexpr size_t call_size{sizeof...(callables)}; 40| 266k| static_assert(call_size >= 1); 41| 266k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 266k| size_t i{0}; 44| 533k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 251k, False: 15.1k] | Branch (44:7): [True: 15.1k, False: 251k] ------------------ 45| 266k| return call_size; 46| 266k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm16ELm16EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 590k|{ 39| 590k| constexpr size_t call_size{sizeof...(callables)}; 40| 590k| static_assert(call_size >= 1); 41| 590k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 590k| size_t i{0}; 44| 1.18M| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 519k, False: 71.1k] | Branch (44:7): [True: 71.1k, False: 519k] ------------------ 45| 590k| return call_size; 46| 590k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm16EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 106k|{ 39| 106k| constexpr size_t call_size{sizeof...(callables)}; 40| 106k| static_assert(call_size >= 1); 41| 106k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 106k| size_t i{0}; 44| 212k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 101k, False: 4.06k] | Branch (44:7): [True: 4.06k, False: 101k] ------------------ 45| 106k| return call_size; 46| 106k|} poolresource.cpp:_Z9CallOneOfIJZN12_GLOBAL__N_118PoolResourceFuzzerILm256ELm64EE4FuzzEvEUlvE_ZNS2_4FuzzEvEUlvE0_EEmR18FuzzedDataProviderDpT_: 38| 480k|{ 39| 480k| constexpr size_t call_size{sizeof...(callables)}; 40| 480k| static_assert(call_size >= 1); 41| 480k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 480k| size_t i{0}; 44| 961k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 430k, False: 50.0k] | Branch (44:7): [True: 50.0k, False: 430k] ------------------ 45| 480k| return call_size; 46| 480k|} _ZN12CheckGlobalsC2Ev: 59| 3.95k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 3.95k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 3.95k| { 18| 3.95k| g_used_g_prng = false; 19| 3.95k| g_seeded_g_prng_zero = false; 20| 3.95k| g_used_system_time = false; 21| 3.95k| SetMockTime(0s); 22| 3.95k| MockableSteadyClock::ClearMockTime(); 23| 3.95k| } _ZN16CheckGlobalsImplD2Ev: 25| 3.95k| { 26| 3.95k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 3.95k] | 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| 3.95k| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 3.95k] ------------------ 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| 3.95k| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN18PoolResourceTester24CheckAllDataAccountedForILm128ELm1EEEvRK12PoolResourceIXT_EXT0_EE: 80| 522| { 81| | // collect all free blocks by iterating all freelists 82| 522| std::vector free_blocks; 83| 9.39k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 8.87k, False: 522] ------------------ 84| 8.87k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 8.87k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 410k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 402k, False: 8.87k] ------------------ 87| 402k| free_blocks.emplace_back(ptr, bytes); 88| 402k| const auto* ptr_ = ptr; 89| 402k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 402k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 402k| ptr = ptr->m_next; 91| 402k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 402k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 402k| } 93| 8.87k| } 94| | // also add whatever has not yet been used for blocks 95| 522| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 522| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 505, False: 17] ------------------ 97| 505| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 505| } 99| | 100| | // collect all chunks 101| 522| std::vector chunks; 102| 119k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 119k, False: 522] ------------------ 103| 119k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 119k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 522| std::sort(free_blocks.begin(), free_blocks.end()); 109| 522| std::sort(chunks.begin(), chunks.end()); 110| | 111| 522| auto chunk_it = chunks.begin(); 112| 522| auto chunk_ptr_remaining = chunk_it->ptr; 113| 522| auto chunk_size_remaining = chunk_it->size; 114| 402k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 402k, False: 522] ------------------ 115| 402k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 118k, False: 283k] ------------------ 116| 118k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 118k, False: 0] ------------------ 117| 118k| ++chunk_it; 118| 118k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 118k, False: 0] ------------------ 119| 118k| chunk_ptr_remaining = chunk_it->ptr; 120| 118k| chunk_size_remaining = chunk_it->size; 121| 118k| } 122| 402k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 402k, False: 0] ------------------ 123| 402k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 402k, False: 0] ------------------ 124| 402k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 402k, False: 0] ------------------ 125| 402k| chunk_ptr_remaining += free_block.size; 126| 402k| chunk_size_remaining -= free_block.size; 127| 402k| } 128| | // ensure we are at the end of the chunks 129| 522| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 522, False: 0] ------------------ 130| 522| ++chunk_it; 131| 522| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 522, False: 0] ------------------ 132| 522| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 522, False: 0] ------------------ 133| 522| } _ZN18PoolResourceTester11PtrAndBytesC2EPKvm: 27| 3.30M| : ptr(reinterpret_cast(p)), size(s) 28| 3.30M| { 29| 3.30M| } _ZltRKN18PoolResourceTester11PtrAndBytesES2_: 35| 79.6M| { 36| 79.6M| return a.ptr < b.ptr; 37| 79.6M| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm128ELm2EEEvRK12PoolResourceIXT_EXT0_EE: 80| 493| { 81| | // collect all free blocks by iterating all freelists 82| 493| std::vector free_blocks; 83| 8.87k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 8.38k, False: 493] ------------------ 84| 8.38k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 8.38k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 315k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 307k, False: 8.38k] ------------------ 87| 307k| free_blocks.emplace_back(ptr, bytes); 88| 307k| const auto* ptr_ = ptr; 89| 307k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 307k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 307k| ptr = ptr->m_next; 91| 307k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 307k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 307k| } 93| 8.38k| } 94| | // also add whatever has not yet been used for blocks 95| 493| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 493| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 481, False: 12] ------------------ 97| 481| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 481| } 99| | 100| | // collect all chunks 101| 493| std::vector chunks; 102| 95.2k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 95.2k, False: 493] ------------------ 103| 95.2k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 95.2k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 493| std::sort(free_blocks.begin(), free_blocks.end()); 109| 493| std::sort(chunks.begin(), chunks.end()); 110| | 111| 493| auto chunk_it = chunks.begin(); 112| 493| auto chunk_ptr_remaining = chunk_it->ptr; 113| 493| auto chunk_size_remaining = chunk_it->size; 114| 307k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 307k, False: 493] ------------------ 115| 307k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 94.7k, False: 212k] ------------------ 116| 94.7k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 94.7k, False: 0] ------------------ 117| 94.7k| ++chunk_it; 118| 94.7k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 94.7k, False: 0] ------------------ 119| 94.7k| chunk_ptr_remaining = chunk_it->ptr; 120| 94.7k| chunk_size_remaining = chunk_it->size; 121| 94.7k| } 122| 307k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 307k, False: 0] ------------------ 123| 307k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 307k, False: 0] ------------------ 124| 307k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 307k, False: 0] ------------------ 125| 307k| chunk_ptr_remaining += free_block.size; 126| 307k| chunk_size_remaining -= free_block.size; 127| 307k| } 128| | // ensure we are at the end of the chunks 129| 493| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 493, False: 0] ------------------ 130| 493| ++chunk_it; 131| 493| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 493, False: 0] ------------------ 132| 493| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 493, False: 0] ------------------ 133| 493| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm128ELm4EEEvRK12PoolResourceIXT_EXT0_EE: 80| 389| { 81| | // collect all free blocks by iterating all freelists 82| 389| std::vector free_blocks; 83| 7.00k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 6.61k, False: 389] ------------------ 84| 6.61k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 6.61k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 199k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 193k, False: 6.61k] ------------------ 87| 193k| free_blocks.emplace_back(ptr, bytes); 88| 193k| const auto* ptr_ = ptr; 89| 193k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 193k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 193k| ptr = ptr->m_next; 91| 193k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 193k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 193k| } 93| 6.61k| } 94| | // also add whatever has not yet been used for blocks 95| 389| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 389| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 379, False: 10] ------------------ 97| 379| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 379| } 99| | 100| | // collect all chunks 101| 389| std::vector chunks; 102| 65.1k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 65.1k, False: 389] ------------------ 103| 65.1k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 65.1k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 389| std::sort(free_blocks.begin(), free_blocks.end()); 109| 389| std::sort(chunks.begin(), chunks.end()); 110| | 111| 389| auto chunk_it = chunks.begin(); 112| 389| auto chunk_ptr_remaining = chunk_it->ptr; 113| 389| auto chunk_size_remaining = chunk_it->size; 114| 193k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 193k, False: 389] ------------------ 115| 193k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 64.7k, False: 128k] ------------------ 116| 64.7k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 64.7k, False: 0] ------------------ 117| 64.7k| ++chunk_it; 118| 64.7k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 64.7k, False: 0] ------------------ 119| 64.7k| chunk_ptr_remaining = chunk_it->ptr; 120| 64.7k| chunk_size_remaining = chunk_it->size; 121| 64.7k| } 122| 193k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 193k, False: 0] ------------------ 123| 193k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 193k, False: 0] ------------------ 124| 193k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 193k, False: 0] ------------------ 125| 193k| chunk_ptr_remaining += free_block.size; 126| 193k| chunk_size_remaining -= free_block.size; 127| 193k| } 128| | // ensure we are at the end of the chunks 129| 389| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 389, False: 0] ------------------ 130| 389| ++chunk_it; 131| 389| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 389, False: 0] ------------------ 132| 389| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 389, False: 0] ------------------ 133| 389| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm128ELm8EEEvRK12PoolResourceIXT_EXT0_EE: 80| 582| { 81| | // collect all free blocks by iterating all freelists 82| 582| std::vector free_blocks; 83| 10.4k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 9.89k, False: 582] ------------------ 84| 9.89k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 9.89k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 370k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 360k, False: 9.89k] ------------------ 87| 360k| free_blocks.emplace_back(ptr, bytes); 88| 360k| const auto* ptr_ = ptr; 89| 360k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 360k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 360k| ptr = ptr->m_next; 91| 360k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 360k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 360k| } 93| 9.89k| } 94| | // also add whatever has not yet been used for blocks 95| 582| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 582| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 571, False: 11] ------------------ 97| 571| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 571| } 99| | 100| | // collect all chunks 101| 582| std::vector chunks; 102| 92.1k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 92.1k, False: 582] ------------------ 103| 92.1k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 92.1k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 582| std::sort(free_blocks.begin(), free_blocks.end()); 109| 582| std::sort(chunks.begin(), chunks.end()); 110| | 111| 582| auto chunk_it = chunks.begin(); 112| 582| auto chunk_ptr_remaining = chunk_it->ptr; 113| 582| auto chunk_size_remaining = chunk_it->size; 114| 361k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 361k, False: 582] ------------------ 115| 361k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 91.5k, False: 269k] ------------------ 116| 91.5k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 91.5k, False: 0] ------------------ 117| 91.5k| ++chunk_it; 118| 91.5k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 91.5k, False: 0] ------------------ 119| 91.5k| chunk_ptr_remaining = chunk_it->ptr; 120| 91.5k| chunk_size_remaining = chunk_it->size; 121| 91.5k| } 122| 361k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 361k, False: 0] ------------------ 123| 361k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 361k, False: 0] ------------------ 124| 361k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 361k, False: 0] ------------------ 125| 361k| chunk_ptr_remaining += free_block.size; 126| 361k| chunk_size_remaining -= free_block.size; 127| 361k| } 128| | // ensure we are at the end of the chunks 129| 582| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 582, False: 0] ------------------ 130| 582| ++chunk_it; 131| 582| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 582, False: 0] ------------------ 132| 582| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 582, False: 0] ------------------ 133| 582| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm8ELm8EEEvRK12PoolResourceIXT_EXT0_EE: 80| 395| { 81| | // collect all free blocks by iterating all freelists 82| 395| std::vector free_blocks; 83| 1.18k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 790, False: 395] ------------------ 84| 790| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 790| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 212k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 211k, False: 790] ------------------ 87| 211k| free_blocks.emplace_back(ptr, bytes); 88| 211k| const auto* ptr_ = ptr; 89| 211k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 211k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 211k| ptr = ptr->m_next; 91| 211k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 211k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 211k| } 93| 790| } 94| | // also add whatever has not yet been used for blocks 95| 395| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 395| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 274, False: 121] ------------------ 97| 274| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 274| } 99| | 100| | // collect all chunks 101| 395| std::vector chunks; 102| 50.2k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 50.2k, False: 395] ------------------ 103| 50.2k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 50.2k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 395| std::sort(free_blocks.begin(), free_blocks.end()); 109| 395| std::sort(chunks.begin(), chunks.end()); 110| | 111| 395| auto chunk_it = chunks.begin(); 112| 395| auto chunk_ptr_remaining = chunk_it->ptr; 113| 395| auto chunk_size_remaining = chunk_it->size; 114| 211k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 211k, False: 395] ------------------ 115| 211k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 49.8k, False: 162k] ------------------ 116| 49.8k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 49.8k, False: 0] ------------------ 117| 49.8k| ++chunk_it; 118| 49.8k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 49.8k, False: 0] ------------------ 119| 49.8k| chunk_ptr_remaining = chunk_it->ptr; 120| 49.8k| chunk_size_remaining = chunk_it->size; 121| 49.8k| } 122| 211k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 211k, False: 0] ------------------ 123| 211k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 211k, False: 0] ------------------ 124| 211k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 211k, False: 0] ------------------ 125| 211k| chunk_ptr_remaining += free_block.size; 126| 211k| chunk_size_remaining -= free_block.size; 127| 211k| } 128| | // ensure we are at the end of the chunks 129| 395| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 395, False: 0] ------------------ 130| 395| ++chunk_it; 131| 395| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 395, False: 0] ------------------ 132| 395| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 395, False: 0] ------------------ 133| 395| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm16ELm16EEEvRK12PoolResourceIXT_EXT0_EE: 80| 592| { 81| | // collect all free blocks by iterating all freelists 82| 592| std::vector free_blocks; 83| 1.77k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 1.18k, False: 592] ------------------ 84| 1.18k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 1.18k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 500k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 499k, False: 1.18k] ------------------ 87| 499k| free_blocks.emplace_back(ptr, bytes); 88| 499k| const auto* ptr_ = ptr; 89| 499k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 499k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 499k| ptr = ptr->m_next; 91| 499k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 499k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 499k| } 93| 1.18k| } 94| | // also add whatever has not yet been used for blocks 95| 592| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 592| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 488, False: 104] ------------------ 97| 488| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 488| } 99| | 100| | // collect all chunks 101| 592| std::vector chunks; 102| 51.9k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 51.9k, False: 592] ------------------ 103| 51.9k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 51.9k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 592| std::sort(free_blocks.begin(), free_blocks.end()); 109| 592| std::sort(chunks.begin(), chunks.end()); 110| | 111| 592| auto chunk_it = chunks.begin(); 112| 592| auto chunk_ptr_remaining = chunk_it->ptr; 113| 592| auto chunk_size_remaining = chunk_it->size; 114| 499k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 499k, False: 592] ------------------ 115| 499k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 51.3k, False: 448k] ------------------ 116| 51.3k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 51.3k, False: 0] ------------------ 117| 51.3k| ++chunk_it; 118| 51.3k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 51.3k, False: 0] ------------------ 119| 51.3k| chunk_ptr_remaining = chunk_it->ptr; 120| 51.3k| chunk_size_remaining = chunk_it->size; 121| 51.3k| } 122| 499k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 499k, False: 0] ------------------ 123| 499k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 499k, False: 0] ------------------ 124| 499k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 499k, False: 0] ------------------ 125| 499k| chunk_ptr_remaining += free_block.size; 126| 499k| chunk_size_remaining -= free_block.size; 127| 499k| } 128| | // ensure we are at the end of the chunks 129| 592| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 592, False: 0] ------------------ 130| 592| ++chunk_it; 131| 592| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 592, False: 0] ------------------ 132| 592| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 592, False: 0] ------------------ 133| 592| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm256ELm16EEEvRK12PoolResourceIXT_EXT0_EE: 80| 429| { 81| | // collect all free blocks by iterating all freelists 82| 429| std::vector free_blocks; 83| 7.72k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 7.29k, False: 429] ------------------ 84| 7.29k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 7.29k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 136k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 128k, False: 7.29k] ------------------ 87| 128k| free_blocks.emplace_back(ptr, bytes); 88| 128k| const auto* ptr_ = ptr; 89| 128k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 128k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 128k| ptr = ptr->m_next; 91| 128k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 128k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 128k| } 93| 7.29k| } 94| | // also add whatever has not yet been used for blocks 95| 429| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 429| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 409, False: 20] ------------------ 97| 409| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 409| } 99| | 100| | // collect all chunks 101| 429| std::vector chunks; 102| 37.3k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 37.3k, False: 429] ------------------ 103| 37.3k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 37.3k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 429| std::sort(free_blocks.begin(), free_blocks.end()); 109| 429| std::sort(chunks.begin(), chunks.end()); 110| | 111| 429| auto chunk_it = chunks.begin(); 112| 429| auto chunk_ptr_remaining = chunk_it->ptr; 113| 429| auto chunk_size_remaining = chunk_it->size; 114| 129k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 129k, False: 429] ------------------ 115| 129k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 36.9k, False: 92.3k] ------------------ 116| 36.9k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 36.9k, False: 0] ------------------ 117| 36.9k| ++chunk_it; 118| 36.9k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 36.9k, False: 0] ------------------ 119| 36.9k| chunk_ptr_remaining = chunk_it->ptr; 120| 36.9k| chunk_size_remaining = chunk_it->size; 121| 36.9k| } 122| 129k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 129k, False: 0] ------------------ 123| 129k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 129k, False: 0] ------------------ 124| 129k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 129k, False: 0] ------------------ 125| 129k| chunk_ptr_remaining += free_block.size; 126| 129k| chunk_size_remaining -= free_block.size; 127| 129k| } 128| | // ensure we are at the end of the chunks 129| 429| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 429, False: 0] ------------------ 130| 429| ++chunk_it; 131| 429| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 429, False: 0] ------------------ 132| 429| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 429, False: 0] ------------------ 133| 429| } _ZN18PoolResourceTester24CheckAllDataAccountedForILm256ELm64EEEvRK12PoolResourceIXT_EXT0_EE: 80| 551| { 81| | // collect all free blocks by iterating all freelists 82| 551| std::vector free_blocks; 83| 3.30k| for (std::size_t freelist_idx = 0; freelist_idx < resource.m_free_lists.size(); ++freelist_idx) { ------------------ | Branch (83:44): [True: 2.75k, False: 551] ------------------ 84| 2.75k| std::size_t bytes = freelist_idx * resource.ELEM_ALIGN_BYTES; 85| 2.75k| auto* ptr = resource.m_free_lists[freelist_idx]; 86| 541k| while (ptr != nullptr) { ------------------ | Branch (86:20): [True: 538k, False: 2.75k] ------------------ 87| 538k| free_blocks.emplace_back(ptr, bytes); 88| 538k| const auto* ptr_ = ptr; 89| 538k| ASAN_UNPOISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 144| 538k|# define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 90| 538k| ptr = ptr->m_next; 91| 538k| ASAN_POISON_MEMORY_REGION(ptr_, sizeof(typename PoolResource::ListNode)); ------------------ | | 143| 538k|# define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size)) ------------------ 92| 538k| } 93| 2.75k| } 94| | // also add whatever has not yet been used for blocks 95| 551| auto num_available_bytes = resource.m_available_memory_end - resource.m_available_memory_it; 96| 551| if (num_available_bytes > 0) { ------------------ | Branch (96:13): [True: 520, False: 31] ------------------ 97| 520| free_blocks.emplace_back(resource.m_available_memory_it, num_available_bytes); 98| 520| } 99| | 100| | // collect all chunks 101| 551| std::vector chunks; 102| 147k| for (const std::byte* ptr : resource.m_allocated_chunks) { ------------------ | Branch (102:35): [True: 147k, False: 551] ------------------ 103| 147k| chunks.emplace_back(ptr, resource.ChunkSizeBytes()); 104| 147k| } 105| | 106| | // now we have all the data from all freelists on the one hand side, and all chunks on the other hand side. 107| | // To check if all of them match, sort by address and iterate. 108| 551| std::sort(free_blocks.begin(), free_blocks.end()); 109| 551| std::sort(chunks.begin(), chunks.end()); 110| | 111| 551| auto chunk_it = chunks.begin(); 112| 551| auto chunk_ptr_remaining = chunk_it->ptr; 113| 551| auto chunk_size_remaining = chunk_it->size; 114| 538k| for (const auto& free_block : free_blocks) { ------------------ | Branch (114:37): [True: 538k, False: 551] ------------------ 115| 538k| if (chunk_size_remaining == 0) { ------------------ | Branch (115:17): [True: 146k, False: 392k] ------------------ 116| 146k| assert(chunk_it != chunks.end()); ------------------ | Branch (116:17): [True: 146k, False: 0] ------------------ 117| 146k| ++chunk_it; 118| 146k| assert(chunk_it != chunks.end()); ------------------ | Branch (118:17): [True: 146k, False: 0] ------------------ 119| 146k| chunk_ptr_remaining = chunk_it->ptr; 120| 146k| chunk_size_remaining = chunk_it->size; 121| 146k| } 122| 538k| assert(free_block.ptr == chunk_ptr_remaining); // ensure addresses match ------------------ | Branch (122:13): [True: 538k, False: 0] ------------------ 123| 538k| assert(free_block.size <= chunk_size_remaining); // ensure no overflow ------------------ | Branch (123:13): [True: 538k, False: 0] ------------------ 124| 538k| assert((free_block.ptr & (resource.ELEM_ALIGN_BYTES - 1)) == 0); // ensure correct alignment ------------------ | Branch (124:13): [True: 538k, False: 0] ------------------ 125| 538k| chunk_ptr_remaining += free_block.size; 126| 538k| chunk_size_remaining -= free_block.size; 127| 538k| } 128| | // ensure we are at the end of the chunks 129| 551| assert(chunk_ptr_remaining == chunk_it->ptr + chunk_it->size); ------------------ | Branch (129:9): [True: 551, False: 0] ------------------ 130| 551| ++chunk_it; 131| 551| assert(chunk_it == chunks.end()); ------------------ | Branch (131:9): [True: 551, False: 0] ------------------ 132| 551| assert(chunk_size_remaining == 0); ------------------ | Branch (132:9): [True: 551, False: 0] ------------------ 133| 551| } _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| 3.95k|{ 91| 3.95k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 3.95k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 3.95k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 3.95k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 3.95k| } 96| 3.95k| return std::forward(val); 97| 3.95k|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 3.95k|{ 91| 3.95k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 3.95k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 3.95k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 3.95k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 3.95k| } 96| 3.95k| return std::forward(val); 97| 3.95k|} _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|} _Z7CeilDivITkNSt3__117unsigned_integralEmTkNS0_17unsigned_integralEmEDaT_T0_: 71| 4.33M|{ 72| 4.33M| assert(divisor > 0); ------------------ | Branch (72:5): [True: 4.33M, False: 0] ------------------ 73| 4.33M| return dividend / divisor + (dividend % divisor != 0); 74| 4.33M|} _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| 3.95k|{ 55| 3.95k| Assert(mock_time_in >= 0s); ------------------ | | 116| 3.95k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 3.95k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 3.95k|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 3.95k|{ 85| 3.95k| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 3.95k|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;