_ZN11ArgsManagerD2Ev: 130| 2|ArgsManager::~ArgsManager() = default; _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|} _ZN9ChainCodeD2Ev: 28| 2| ~ChainCode() { memory_cleanse(data(), size()); } _ZN11CNetCleanupD2Ev: 3676| 2| { 3677| |#ifdef WIN32 3678| | // Shutdown Windows Sockets 3679| | WSACleanup(); 3680| |#endif 3681| 2| } _ZNK9prevectorILj16EhjiE9is_directEv: 126| 16| bool is_direct() const { return _size <= N; } _ZN9prevectorILj16EhjiED2Ev: 422| 16| ~prevector() { 423| 16| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 16] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 16| } _ZNK9prevectorILj36EhjiE9is_directEv: 126| 14| bool is_direct() const { return _size <= N; } _ZN9prevectorILj36EhjiED2Ev: 422| 14| ~prevector() { 423| 14| if (!is_direct()) { ------------------ | Branch (423:13): [True: 0, False: 14] ------------------ 424| 0| free(_union.indirect_contents.indirect); 425| 0| _union.indirect_contents.indirect = nullptr; 426| 0| } 427| 14| } random.cpp:_ZN12_GLOBAL__N_18RNGStateD2Ev: 367| 2| ~RNGState() = default; _ZN20BaseSignatureCheckerD2Ev: 298| 2| virtual ~BaseSignatureChecker() = default; _ZN20BaseSignatureCreatorD2Ev: 41| 4| virtual ~BaseSignatureCreator() = default; _ZN15SigningProviderD2Ev: 170| 2| virtual ~SigningProvider() = default; 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| } _ZN18FuzzedDataProvider15ConsumeIntegralItEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 4.27k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 3.57k, False: 700] | Branch (217:43): [True: 3.57k, False: 0] ------------------ 218| 3.57k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 1.41k, False: 2.15k] ------------------ 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| 1.41k| --remaining_bytes_; 226| 1.41k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 1.41k| offset += CHAR_BIT; 228| 1.41k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralImEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIaEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIaEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 3.38k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 2.85k, False: 527] | Branch (217:43): [True: 2.85k, False: 0] ------------------ 218| 2.85k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 527, False: 2.32k] ------------------ 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| 527| --remaining_bytes_; 226| 527| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 527| offset += CHAR_BIT; 228| 527| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIcEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIcEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 3.50k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 2.85k, False: 647] | Branch (217:43): [True: 2.85k, False: 0] ------------------ 218| 2.85k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 647, False: 2.20k] ------------------ 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| 647| --remaining_bytes_; 226| 647| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 647| offset += CHAR_BIT; 228| 647| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIsEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIsEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 4.61k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 3.74k, False: 867] | Branch (217:43): [True: 3.74k, False: 0] ------------------ 218| 3.74k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 1.75k, False: 1.98k] ------------------ 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| 1.75k| --remaining_bytes_; 226| 1.75k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 1.75k| offset += CHAR_BIT; 228| 1.75k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProviderC2EPKhm: 37| 1.42k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 3.42k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 2.85k, False: 570] | Branch (217:43): [True: 2.85k, False: 0] ------------------ 218| 2.85k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 570, False: 2.28k] ------------------ 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| 570| --remaining_bytes_; 226| 570| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 570| offset += CHAR_BIT; 228| 570| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 15.8k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 14.2k, False: 1.58k] | Branch (217:43): [True: 14.2k, False: 0] ------------------ 218| 14.2k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 12.9k, False: 1.27k] ------------------ 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| 12.9k| --remaining_bytes_; 226| 12.9k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 12.9k| offset += CHAR_BIT; 228| 12.9k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 0, False: 2.85k] ------------------ 232| 0| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 6.75k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 5.79k, False: 954] | Branch (217:43): [True: 5.79k, False: 0] ------------------ 218| 5.79k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 3.89k, False: 1.90k] ------------------ 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| 3.89k| --remaining_bytes_; 226| 3.89k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 3.89k| offset += CHAR_BIT; 228| 3.89k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v: 195| 2.85k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 2.85k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 2.85k| std::numeric_limits::max()); 198| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 22.9k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 20.5k, False: 2.43k] | Branch (217:43): [True: 20.5k, False: 0] ------------------ 218| 20.5k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 20.1k, False: 417] ------------------ 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| 20.1k| --remaining_bytes_; 226| 20.1k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 20.1k| offset += CHAR_BIT; 228| 20.1k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 0, False: 2.85k] ------------------ 232| 0| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_: 205| 2.85k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 2.85k| static_assert(std::is_integral_v, "An integral type is required."); 207| 2.85k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 2.85k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 2.85k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 2.85k| uint64_t range = static_cast(max) - static_cast(min); 214| 2.85k| uint64_t result = 0; 215| 2.85k| size_t offset = 0; 216| | 217| 8.46k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 7.10k, False: 1.36k] | Branch (217:43): [True: 7.10k, False: 0] ------------------ 218| 7.10k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 5.61k, False: 1.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| 5.61k| --remaining_bytes_; 226| 5.61k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 5.61k| offset += CHAR_BIT; 228| 5.61k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 2.85k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 2.85k, False: 0] ------------------ 232| 2.85k| result = result % (range + 1); 233| | 234| 2.85k| return static_cast(static_cast(min) + result); 235| 2.85k|} _Z29addition_overflow_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 46| 1.42k|{ 47| 1.42k| FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); 48| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 49| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 50| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 51| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 52| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 53| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 54| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 55| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 56| 1.42k| TestAdditionOverflow(fuzzed_data_provider); 57| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIlEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 887, False: 540] ------------------ 32| 887| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 887, False: 0] ------------------ 33| 887| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 540, False: 887] ------------------ 36| 540| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 388, False: 152] | Branch (36:9): [True: 152, False: 0] | Branch (36:9): [True: 540, False: 0] ------------------ 37| 887| } else { 38| 887| const auto add{i + j}; 39| 887| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 887, False: 0] ------------------ 40| 887| assert(add == sat_add); ------------------ | Branch (40:9): [True: 887, False: 0] ------------------ 41| 887| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowImEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 1.11k, False: 313] ------------------ 32| 1.11k| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 1.11k, False: 0] ------------------ 33| 1.11k| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 313, False: 1.11k] ------------------ 36| 313| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 0, False: 313] | Branch (36:9): [True: 313, False: 0] | Branch (36:9): [True: 313, False: 0] ------------------ 37| 1.11k| } else { 38| 1.11k| const auto add{i + j}; 39| 1.11k| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 1.11k, False: 0] ------------------ 40| 1.11k| assert(add == sat_add); ------------------ | Branch (40:9): [True: 1.11k, False: 0] ------------------ 41| 1.11k| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIiEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 403, False: 1.02k] ------------------ 32| 403| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 403, False: 0] ------------------ 33| 403| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 1.02k, False: 403] ------------------ 36| 1.02k| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 916, False: 108] | Branch (36:9): [True: 108, False: 0] | Branch (36:9): [True: 1.02k, False: 0] ------------------ 37| 1.02k| } else { 38| 403| const auto add{i + j}; 39| 403| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 403, False: 0] ------------------ 40| 403| assert(add == sat_add); ------------------ | Branch (40:9): [True: 403, False: 0] ------------------ 41| 403| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIjEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 1.26k, False: 164] ------------------ 32| 1.26k| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 1.26k, False: 0] ------------------ 33| 1.26k| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 164, False: 1.26k] ------------------ 36| 164| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 0, False: 164] | Branch (36:9): [True: 164, False: 0] | Branch (36:9): [True: 164, False: 0] ------------------ 37| 1.26k| } else { 38| 1.26k| const auto add{i + j}; 39| 1.26k| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 1.26k, False: 0] ------------------ 40| 1.26k| assert(add == sat_add); ------------------ | Branch (40:9): [True: 1.26k, False: 0] ------------------ 41| 1.26k| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIsEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 233, False: 1.19k] ------------------ 32| 233| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 233, False: 0] ------------------ 33| 233| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 1.19k, False: 233] ------------------ 36| 1.19k| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 1.13k, False: 60] | Branch (36:9): [True: 60, False: 0] | Branch (36:9): [True: 1.19k, False: 0] ------------------ 37| 1.19k| } else { 38| 233| const auto add{i + j}; 39| 233| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 233, False: 0] ------------------ 40| 233| assert(add == sat_add); ------------------ | Branch (40:9): [True: 233, False: 0] ------------------ 41| 233| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowItEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 1.29k, False: 130] ------------------ 32| 1.29k| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 1.29k, False: 0] ------------------ 33| 1.29k| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 130, False: 1.29k] ------------------ 36| 130| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 0, False: 130] | Branch (36:9): [True: 130, False: 0] | Branch (36:9): [True: 130, False: 0] ------------------ 37| 1.29k| } else { 38| 1.29k| const auto add{i + j}; 39| 1.29k| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 1.29k, False: 0] ------------------ 40| 1.29k| assert(add == sat_add); ------------------ | Branch (40:9): [True: 1.29k, False: 0] ------------------ 41| 1.29k| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIcEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 147, False: 1.28k] ------------------ 32| 147| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 147, False: 0] ------------------ 33| 147| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 1.28k, False: 147] ------------------ 36| 1.28k| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 1.23k, False: 41] | Branch (36:9): [True: 41, False: 0] | Branch (36:9): [True: 1.28k, False: 0] ------------------ 37| 1.28k| } else { 38| 147| const auto add{i + j}; 39| 147| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 147, False: 0] ------------------ 40| 147| assert(add == sat_add); ------------------ | Branch (40:9): [True: 147, False: 0] ------------------ 41| 147| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIhEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 1.34k, False: 84] ------------------ 32| 1.34k| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 1.34k, False: 0] ------------------ 33| 1.34k| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 84, False: 1.34k] ------------------ 36| 84| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 0, False: 84] | Branch (36:9): [True: 84, False: 0] | Branch (36:9): [True: 84, False: 0] ------------------ 37| 1.34k| } else { 38| 1.34k| const auto add{i + j}; 39| 1.34k| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 1.34k, False: 0] ------------------ 40| 1.34k| assert(add == sat_add); ------------------ | Branch (40:9): [True: 1.34k, False: 0] ------------------ 41| 1.34k| } 42| 1.42k|} addition_overflow.cpp:_ZN12_GLOBAL__N_120TestAdditionOverflowIaEEvR18FuzzedDataProvider: 17| 1.42k|{ 18| 1.42k| const T i = fuzzed_data_provider.ConsumeIntegral(); 19| 1.42k| const T j = fuzzed_data_provider.ConsumeIntegral(); 20| 1.42k| const bool is_addition_overflow_custom = AdditionOverflow(i, j); 21| 1.42k| const auto maybe_add{CheckedAdd(i, j)}; 22| 1.42k| const auto sat_add{SaturatingAdd(i, j)}; 23| 1.42k| assert(is_addition_overflow_custom == !maybe_add.has_value()); ------------------ | Branch (23:5): [True: 1.42k, False: 0] ------------------ 24| 1.42k| assert(is_addition_overflow_custom == AdditionOverflow(j, i)); ------------------ | Branch (24:5): [True: 1.42k, False: 0] ------------------ 25| 1.42k| assert(maybe_add == CheckedAdd(j, i)); ------------------ | Branch (25:5): [True: 1.42k, False: 0] ------------------ 26| 1.42k| assert(sat_add == SaturatingAdd(j, i)); ------------------ | Branch (26:5): [True: 1.42k, False: 0] ------------------ 27| 1.42k|#ifndef _MSC_VER 28| 1.42k| T result_builtin; 29| 1.42k| const bool is_addition_overflow_builtin = __builtin_add_overflow(i, j, &result_builtin); 30| 1.42k| assert(is_addition_overflow_custom == is_addition_overflow_builtin); ------------------ | Branch (30:5): [True: 1.42k, False: 0] ------------------ 31| 1.42k| if (!is_addition_overflow_custom) { ------------------ | Branch (31:9): [True: 120, False: 1.30k] ------------------ 32| 120| assert(i + j == result_builtin); ------------------ | Branch (32:9): [True: 120, False: 0] ------------------ 33| 120| } 34| 1.42k|#endif 35| 1.42k| if (is_addition_overflow_custom) { ------------------ | Branch (35:9): [True: 1.30k, False: 120] ------------------ 36| 1.30k| assert(sat_add == std::numeric_limits::min() || sat_add == std::numeric_limits::max()); ------------------ | Branch (36:9): [True: 1.28k, False: 25] | Branch (36:9): [True: 25, False: 0] | Branch (36:9): [True: 1.30k, False: 0] ------------------ 37| 1.30k| } else { 38| 120| const auto add{i + j}; 39| 120| assert(add == maybe_add.value()); ------------------ | Branch (39:9): [True: 120, False: 0] ------------------ 40| 120| assert(add == sat_add); ------------------ | Branch (40:9): [True: 120, False: 0] ------------------ 41| 120| } 42| 1.42k|} LLVMFuzzerTestOneInput: 213| 1.42k|{ 214| 1.42k| test_one_input({data, size}); 215| 1.42k| return 0; 216| 1.42k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 1.42k|{ 85| 1.42k| CheckGlobals check{}; 86| 1.42k| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 1.42k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 1.42k|} _ZN12CheckGlobalsC2Ev: 59| 1.42k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 1.42k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 1.42k| { 18| 1.42k| g_used_g_prng = false; 19| 1.42k| g_seeded_g_prng_zero = false; 20| 1.42k| g_used_system_time = false; 21| 1.42k| SetMockTime(0s); 22| 1.42k| MockableSteadyClock::ClearMockTime(); 23| 1.42k| } _ZN16CheckGlobalsImplD2Ev: 25| 1.42k| { 26| 1.42k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 1.42k] | 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| 1.42k| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 1.42k] ------------------ 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| 1.42k| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN9base_blobILj256EE4dataEv: 99| 2| constexpr unsigned char* data() { return m_data.data(); } _ZN9base_blobILj256EE4sizeEv: 107| 2| static constexpr unsigned int size() { return WIDTH; } _ZN10btcsignals6signalIFvvENS_10null_valueEED2Ev: 175| 6| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStatellbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFv20SynchronizationStateRK11CBlockIndexdENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEibENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvbENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFviENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFbRK13bilingual_strRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEjENS_6any_ofEED2Ev: 175| 2| ~signal() = default; _ZN10btcsignals6signalIFvRK13bilingual_strjENS_10null_valueEED2Ev: 175| 2| ~signal() = default; _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_RKNS0_15source_locationENS0_17basic_string_viewIcNS0_11char_traitsIcEEEE: 90| 1.42k|{ 91| 1.42k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 1.42k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 1.42k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 1.42k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 1.42k| } 96| 1.42k| return std::forward(val); 97| 1.42k|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 1.42k|{ 91| 1.42k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 1.42k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 1.42k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 1.42k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 1.42k| } 96| 1.42k| return std::forward(val); 97| 1.42k|} _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|} _Z16AdditionOverflowITkNSt3__18integralEcEbT_S1_: 18| 5.70k|{ 19| 5.70k| if constexpr (std::numeric_limits::is_signed) { 20| 5.70k| return (i > 0 && j > std::numeric_limits::max() - i) || ------------------ | Branch (20:17): [True: 380, False: 5.32k] | Branch (20:26): [True: 164, False: 216] ------------------ 21| 5.54k| (i < 0 && j < std::numeric_limits::min() - i); ------------------ | Branch (21:17): [True: 5.28k, False: 258] | Branch (21:26): [True: 4.95k, False: 330] ------------------ 22| 5.70k| } 23| 0| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z10CheckedAddIcENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 2.56k, False: 294] ------------------ 30| 2.56k| return std::nullopt; 31| 2.56k| } 32| 294| return i + j; 33| 2.85k|} _Z13SaturatingAddITkNSt3__18integralEcET_S1_S1_: 45| 2.85k|{ 46| 2.85k| if constexpr (std::numeric_limits::is_signed) { 47| 2.85k| if (i > 0 && j > std::numeric_limits::max() - i) { ------------------ | Branch (47:13): [True: 190, False: 2.66k] | Branch (47:22): [True: 82, False: 108] ------------------ 48| 82| return std::numeric_limits::max(); 49| 82| } 50| 2.77k| if (i < 0 && j < std::numeric_limits::min() - i) { ------------------ | Branch (50:13): [True: 2.64k, False: 129] | Branch (50:22): [True: 2.47k, False: 165] ------------------ 51| 2.47k| return std::numeric_limits::min(); 52| 2.47k| } 53| | } else { 54| | if (std::numeric_limits::max() - i < j) { 55| | return std::numeric_limits::max(); 56| | } 57| | } 58| 294| return i + j; 59| 2.85k|} _Z13SaturatingAddITkNSt3__18integralEaET_S1_S1_: 45| 2.85k|{ 46| 2.85k| if constexpr (std::numeric_limits::is_signed) { 47| 2.85k| if (i > 0 && j > std::numeric_limits::max() - i) { ------------------ | Branch (47:13): [True: 131, False: 2.72k] | Branch (47:22): [True: 50, False: 81] ------------------ 48| 50| return std::numeric_limits::max(); 49| 50| } 50| 2.80k| if (i < 0 && j < std::numeric_limits::min() - i) { ------------------ | Branch (50:13): [True: 2.71k, False: 92] | Branch (50:22): [True: 2.56k, False: 148] ------------------ 51| 2.56k| return std::numeric_limits::min(); 52| 2.56k| } 53| | } else { 54| | if (std::numeric_limits::max() - i < j) { 55| | return std::numeric_limits::max(); 56| | } 57| | } 58| 240| return i + j; 59| 2.85k|} _Z10CheckedAddIaENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 2.61k, False: 240] ------------------ 30| 2.61k| return std::nullopt; 31| 2.61k| } 32| 240| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEaEbT_S1_: 18| 5.70k|{ 19| 5.70k| if constexpr (std::numeric_limits::is_signed) { 20| 5.70k| return (i > 0 && j > std::numeric_limits::max() - i) || ------------------ | Branch (20:17): [True: 262, False: 5.44k] | Branch (20:26): [True: 100, False: 162] ------------------ 21| 5.60k| (i < 0 && j < std::numeric_limits::min() - i); ------------------ | Branch (21:17): [True: 5.42k, False: 184] | Branch (21:26): [True: 5.12k, False: 296] ------------------ 22| 5.70k| } 23| 0| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralEsET_S1_S1_: 45| 2.85k|{ 46| 2.85k| if constexpr (std::numeric_limits::is_signed) { 47| 2.85k| if (i > 0 && j > std::numeric_limits::max() - i) { ------------------ | Branch (47:13): [True: 339, False: 2.51k] | Branch (47:22): [True: 120, False: 219] ------------------ 48| 120| return std::numeric_limits::max(); 49| 120| } 50| 2.73k| if (i < 0 && j < std::numeric_limits::min() - i) { ------------------ | Branch (50:13): [True: 2.50k, False: 230] | Branch (50:22): [True: 2.26k, False: 236] ------------------ 51| 2.26k| return std::numeric_limits::min(); 52| 2.26k| } 53| | } else { 54| | if (std::numeric_limits::max() - i < j) { 55| | return std::numeric_limits::max(); 56| | } 57| | } 58| 466| return i + j; 59| 2.85k|} _Z10CheckedAddIsENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 2.38k, False: 466] ------------------ 30| 2.38k| return std::nullopt; 31| 2.38k| } 32| 466| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEsEbT_S1_: 18| 5.70k|{ 19| 5.70k| if constexpr (std::numeric_limits::is_signed) { 20| 5.70k| return (i > 0 && j > std::numeric_limits::max() - i) || ------------------ | Branch (20:17): [True: 678, False: 5.03k] | Branch (20:26): [True: 240, False: 438] ------------------ 21| 5.46k| (i < 0 && j < std::numeric_limits::min() - i); ------------------ | Branch (21:17): [True: 5.00k, False: 460] | Branch (21:26): [True: 4.53k, False: 472] ------------------ 22| 5.70k| } 23| 0| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z10CheckedAddIiENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 2.04k, False: 806] ------------------ 30| 2.04k| return std::nullopt; 31| 2.04k| } 32| 806| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEiEbT_S1_: 18| 5.70k|{ 19| 5.70k| if constexpr (std::numeric_limits::is_signed) { 20| 5.70k| return (i > 0 && j > std::numeric_limits::max() - i) || ------------------ | Branch (20:17): [True: 1.10k, False: 4.60k] | Branch (20:26): [True: 432, False: 672] ------------------ 21| 5.27k| (i < 0 && j < std::numeric_limits::min() - i); ------------------ | Branch (21:17): [True: 4.59k, False: 682] | Branch (21:26): [True: 3.66k, False: 930] ------------------ 22| 5.70k| } 23| 0| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralEhET_S1_S1_: 45| 2.85k|{ 46| | if constexpr (std::numeric_limits::is_signed) { 47| | if (i > 0 && j > std::numeric_limits::max() - i) { 48| | return std::numeric_limits::max(); 49| | } 50| | if (i < 0 && j < std::numeric_limits::min() - i) { 51| | return std::numeric_limits::min(); 52| | } 53| 2.85k| } else { 54| 2.85k| if (std::numeric_limits::max() - i < j) { ------------------ | Branch (54:13): [True: 168, False: 2.68k] ------------------ 55| 168| return std::numeric_limits::max(); 56| 168| } 57| 2.85k| } 58| 2.68k| return i + j; 59| 2.85k|} _Z10CheckedAddIhENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 168, False: 2.68k] ------------------ 30| 168| return std::nullopt; 31| 168| } 32| 2.68k| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEhEbT_S1_: 18| 5.70k|{ 19| | if constexpr (std::numeric_limits::is_signed) { 20| | return (i > 0 && j > std::numeric_limits::max() - i) || 21| | (i < 0 && j < std::numeric_limits::min() - i); 22| | } 23| 5.70k| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralEtET_S1_S1_: 45| 2.85k|{ 46| | if constexpr (std::numeric_limits::is_signed) { 47| | if (i > 0 && j > std::numeric_limits::max() - i) { 48| | return std::numeric_limits::max(); 49| | } 50| | if (i < 0 && j < std::numeric_limits::min() - i) { 51| | return std::numeric_limits::min(); 52| | } 53| 2.85k| } else { 54| 2.85k| if (std::numeric_limits::max() - i < j) { ------------------ | Branch (54:13): [True: 260, False: 2.59k] ------------------ 55| 260| return std::numeric_limits::max(); 56| 260| } 57| 2.85k| } 58| 2.59k| return i + j; 59| 2.85k|} _Z10CheckedAddItENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 260, False: 2.59k] ------------------ 30| 260| return std::nullopt; 31| 260| } 32| 2.59k| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEtEbT_S1_: 18| 5.70k|{ 19| | if constexpr (std::numeric_limits::is_signed) { 20| | return (i > 0 && j > std::numeric_limits::max() - i) || 21| | (i < 0 && j < std::numeric_limits::min() - i); 22| | } 23| 5.70k| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralEjET_S1_S1_: 45| 2.85k|{ 46| | if constexpr (std::numeric_limits::is_signed) { 47| | if (i > 0 && j > std::numeric_limits::max() - i) { 48| | return std::numeric_limits::max(); 49| | } 50| | if (i < 0 && j < std::numeric_limits::min() - i) { 51| | return std::numeric_limits::min(); 52| | } 53| 2.85k| } else { 54| 2.85k| if (std::numeric_limits::max() - i < j) { ------------------ | Branch (54:13): [True: 328, False: 2.52k] ------------------ 55| 328| return std::numeric_limits::max(); 56| 328| } 57| 2.85k| } 58| 2.52k| return i + j; 59| 2.85k|} _Z10CheckedAddIjENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 328, False: 2.52k] ------------------ 30| 328| return std::nullopt; 31| 328| } 32| 2.52k| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEjEbT_S1_: 18| 5.70k|{ 19| | if constexpr (std::numeric_limits::is_signed) { 20| | return (i > 0 && j > std::numeric_limits::max() - i) || 21| | (i < 0 && j < std::numeric_limits::min() - i); 22| | } 23| 5.70k| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z10CheckedAddIlENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 1.08k, False: 1.77k] ------------------ 30| 1.08k| return std::nullopt; 31| 1.08k| } 32| 1.77k| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralElEbT_S1_: 18| 5.70k|{ 19| 5.70k| if constexpr (std::numeric_limits::is_signed) { 20| 5.70k| return (i > 0 && j > std::numeric_limits::max() - i) || ------------------ | Branch (20:17): [True: 2.04k, False: 3.66k] | Branch (20:26): [True: 608, False: 1.43k] ------------------ 21| 5.10k| (i < 0 && j < std::numeric_limits::min() - i); ------------------ | Branch (21:17): [True: 3.64k, False: 1.45k] | Branch (21:26): [True: 1.55k, False: 2.09k] ------------------ 22| 5.70k| } 23| 0| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralEiET_S1_S1_: 45| 2.85k|{ 46| 2.85k| if constexpr (std::numeric_limits::is_signed) { 47| 2.85k| if (i > 0 && j > std::numeric_limits::max() - i) { ------------------ | Branch (47:13): [True: 552, False: 2.30k] | Branch (47:22): [True: 216, False: 336] ------------------ 48| 216| return std::numeric_limits::max(); 49| 216| } 50| 2.63k| if (i < 0 && j < std::numeric_limits::min() - i) { ------------------ | Branch (50:13): [True: 2.29k, False: 341] | Branch (50:22): [True: 1.83k, False: 465] ------------------ 51| 1.83k| return std::numeric_limits::min(); 52| 1.83k| } 53| | } else { 54| | if (std::numeric_limits::max() - i < j) { 55| | return std::numeric_limits::max(); 56| | } 57| | } 58| 806| return i + j; 59| 2.85k|} _Z13SaturatingAddITkNSt3__18integralEmET_S1_S1_: 45| 2.85k|{ 46| | if constexpr (std::numeric_limits::is_signed) { 47| | if (i > 0 && j > std::numeric_limits::max() - i) { 48| | return std::numeric_limits::max(); 49| | } 50| | if (i < 0 && j < std::numeric_limits::min() - i) { 51| | return std::numeric_limits::min(); 52| | } 53| 2.85k| } else { 54| 2.85k| if (std::numeric_limits::max() - i < j) { ------------------ | Branch (54:13): [True: 626, False: 2.22k] ------------------ 55| 626| return std::numeric_limits::max(); 56| 626| } 57| 2.85k| } 58| 2.22k| return i + j; 59| 2.85k|} _Z10CheckedAddImENSt3__18optionalIT_EES2_S2_: 28| 2.85k|{ 29| 2.85k| if (AdditionOverflow(i, j)) { ------------------ | Branch (29:9): [True: 626, False: 2.22k] ------------------ 30| 626| return std::nullopt; 31| 626| } 32| 2.22k| return i + j; 33| 2.85k|} _Z16AdditionOverflowITkNSt3__18integralEmEbT_S1_: 18| 5.70k|{ 19| | if constexpr (std::numeric_limits::is_signed) { 20| | return (i > 0 && j > std::numeric_limits::max() - i) || 21| | (i < 0 && j < std::numeric_limits::min() - i); 22| | } 23| 5.70k| return std::numeric_limits::max() - i < j; 24| 5.70k|} _Z13SaturatingAddITkNSt3__18integralElET_S1_S1_: 45| 2.85k|{ 46| 2.85k| if constexpr (std::numeric_limits::is_signed) { 47| 2.85k| if (i > 0 && j > std::numeric_limits::max() - i) { ------------------ | Branch (47:13): [True: 1.02k, False: 1.83k] | Branch (47:22): [True: 304, False: 717] ------------------ 48| 304| return std::numeric_limits::max(); 49| 304| } 50| 2.55k| if (i < 0 && j < std::numeric_limits::min() - i) { ------------------ | Branch (50:13): [True: 1.82k, False: 728] | Branch (50:22): [True: 776, False: 1.04k] ------------------ 51| 776| return std::numeric_limits::min(); 52| 776| } 53| | } else { 54| | if (std::numeric_limits::max() - i < j) { 55| | return std::numeric_limits::max(); 56| | } 57| | } 58| 1.77k| return i + j; 59| 2.85k|} _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| 1.42k|{ 55| 1.42k| Assert(mock_time_in >= 0s); ------------------ | | 116| 1.42k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 1.42k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 1.42k|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 1.42k|{ 85| 1.42k| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 1.42k|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;