_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| 96|template T FuzzedDataProvider::ConsumeIntegral() { 196| 96| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 96| std::numeric_limits::max()); 198| 96|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeItEET_S1_S1_: 205| 96|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 96| static_assert(std::is_integral_v, "An integral type is required."); 207| 96| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 96| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 96] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 96| uint64_t range = static_cast(max) - static_cast(min); 214| 96| uint64_t result = 0; 215| 96| size_t offset = 0; 216| | 217| 166| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 132, False: 34] | Branch (217:43): [True: 132, False: 0] ------------------ 218| 132| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 70, False: 62] ------------------ 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| 70| --remaining_bytes_; 226| 70| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 70| offset += CHAR_BIT; 228| 70| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 96| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 96, False: 0] ------------------ 232| 96| result = result % (range + 1); 233| | 234| 96| return static_cast(static_cast(min) + result); 235| 96|} _ZN18FuzzedDataProvider15ConsumeIntegralImEET_v: 195| 208|template T FuzzedDataProvider::ConsumeIntegral() { 196| 208| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 208| std::numeric_limits::max()); 198| 208|} _ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v: 195| 1.12k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 1.12k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 1.12k| std::numeric_limits::max()); 198| 1.12k|} _ZN18FuzzedDataProvider15ConsumeIntegralIaEET_v: 195| 214|template T FuzzedDataProvider::ConsumeIntegral() { 196| 214| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 214| std::numeric_limits::max()); 198| 214|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIaEET_S1_S1_: 205| 214|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 214| static_assert(std::is_integral_v, "An integral type is required."); 207| 214| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 214| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 214] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 214| uint64_t range = static_cast(max) - static_cast(min); 214| 214| uint64_t result = 0; 215| 214| size_t offset = 0; 216| | 217| 376| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 214, False: 162] | Branch (217:43): [True: 214, False: 0] ------------------ 218| 214| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 162, False: 52] ------------------ 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| 162| --remaining_bytes_; 226| 162| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 162| offset += CHAR_BIT; 228| 162| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 214| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 214, False: 0] ------------------ 232| 214| result = result % (range + 1); 233| | 234| 214| return static_cast(static_cast(min) + result); 235| 214|} _ZN18FuzzedDataProvider15ConsumeIntegralIcEET_v: 195| 216|template T FuzzedDataProvider::ConsumeIntegral() { 196| 216| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 216| std::numeric_limits::max()); 198| 216|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIcEET_S1_S1_: 205| 216|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 216| static_assert(std::is_integral_v, "An integral type is required."); 207| 216| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 216| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 216] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 216| uint64_t range = static_cast(max) - static_cast(min); 214| 216| uint64_t result = 0; 215| 216| size_t offset = 0; 216| | 217| 383| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 216, False: 167] | Branch (217:43): [True: 216, False: 0] ------------------ 218| 216| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 167, False: 49] ------------------ 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| 167| --remaining_bytes_; 226| 167| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 167| offset += CHAR_BIT; 228| 167| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 216| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 216, False: 0] ------------------ 232| 216| result = result % (range + 1); 233| | 234| 216| return static_cast(static_cast(min) + result); 235| 216|} _ZN18FuzzedDataProvider20ConsumeFloatingPointIfEET_v: 240| 1.01k|template T FuzzedDataProvider::ConsumeFloatingPoint() { 241| 1.01k| return ConsumeFloatingPointInRange(std::numeric_limits::lowest(), 242| 1.01k| std::numeric_limits::max()); 243| 1.01k|} _ZN18FuzzedDataProvider27ConsumeFloatingPointInRangeIfEET_S1_S1_: 249| 1.01k|T FuzzedDataProvider::ConsumeFloatingPointInRange(T min, T max) { 250| 1.01k| if (min > max) ------------------ | Branch (250:7): [True: 0, False: 1.01k] ------------------ 251| 0| abort(); 252| | 253| 1.01k| T range = .0; 254| 1.01k| T result = min; 255| 1.01k| constexpr T zero(.0); 256| 1.01k| if (max > zero && min < zero && max > min + std::numeric_limits::max()) { ------------------ | Branch (256:7): [True: 1.01k, False: 0] | Branch (256:21): [True: 1.01k, False: 0] | Branch (256:35): [True: 1.01k, False: 0] ------------------ 257| | // The diff |max - min| would overflow the given floating point type. Use 258| | // the half of the diff as the range and consume a bool to decide whether 259| | // the result is in the first of the second part of the diff. 260| 1.01k| range = (max / 2.0) - (min / 2.0); 261| 1.01k| if (ConsumeBool()) { ------------------ | Branch (261:9): [True: 27, False: 988] ------------------ 262| 27| result += range; 263| 27| } 264| 1.01k| } else { 265| 0| range = max - min; 266| 0| } 267| | 268| 1.01k| return result + range * ConsumeProbability(); 269| 1.01k|} _ZN18FuzzedDataProvider18ConsumeProbabilityIfEET_v: 273| 1.01k|template T FuzzedDataProvider::ConsumeProbability() { 274| 1.01k| static_assert(std::is_floating_point_v, 275| 1.01k| "A floating point type is required."); 276| | 277| | // Use different integral types for different floating point types in order 278| | // to provide better density of the resulting values. 279| 1.01k| using IntegralType = 280| 1.01k| typename std::conditional_t<(sizeof(T) <= sizeof(uint32_t)), uint32_t, 281| 1.01k| uint64_t>; 282| | 283| 1.01k| T result = static_cast(ConsumeIntegral()); 284| 1.01k| result /= static_cast(std::numeric_limits::max()); 285| 1.01k| return result; 286| 1.01k|} _ZN18FuzzedDataProvider20ConsumeFloatingPointIdEET_v: 240| 107|template T FuzzedDataProvider::ConsumeFloatingPoint() { 241| 107| return ConsumeFloatingPointInRange(std::numeric_limits::lowest(), 242| 107| std::numeric_limits::max()); 243| 107|} _ZN18FuzzedDataProvider27ConsumeFloatingPointInRangeIdEET_S1_S1_: 249| 107|T FuzzedDataProvider::ConsumeFloatingPointInRange(T min, T max) { 250| 107| if (min > max) ------------------ | Branch (250:7): [True: 0, False: 107] ------------------ 251| 0| abort(); 252| | 253| 107| T range = .0; 254| 107| T result = min; 255| 107| constexpr T zero(.0); 256| 107| if (max > zero && min < zero && max > min + std::numeric_limits::max()) { ------------------ | Branch (256:7): [True: 107, False: 0] | Branch (256:21): [True: 107, False: 0] | Branch (256:35): [True: 107, False: 0] ------------------ 257| | // The diff |max - min| would overflow the given floating point type. Use 258| | // the half of the diff as the range and consume a bool to decide whether 259| | // the result is in the first of the second part of the diff. 260| 107| range = (max / 2.0) - (min / 2.0); 261| 107| if (ConsumeBool()) { ------------------ | Branch (261:9): [True: 39, False: 68] ------------------ 262| 39| result += range; 263| 39| } 264| 107| } else { 265| 0| range = max - min; 266| 0| } 267| | 268| 107| return result + range * ConsumeProbability(); 269| 107|} _ZN18FuzzedDataProvider18ConsumeProbabilityIdEET_v: 273| 107|template T FuzzedDataProvider::ConsumeProbability() { 274| 107| static_assert(std::is_floating_point_v, 275| 107| "A floating point type is required."); 276| | 277| | // Use different integral types for different floating point types in order 278| | // to provide better density of the resulting values. 279| 107| using IntegralType = 280| 107| typename std::conditional_t<(sizeof(T) <= sizeof(uint32_t)), uint32_t, 281| 107| uint64_t>; 282| | 283| 107| T result = static_cast(ConsumeIntegral()); 284| 107| result /= static_cast(std::numeric_limits::max()); 285| 107| return result; 286| 107|} _ZN18FuzzedDataProvider15ConsumeIntegralIsEET_v: 195| 88|template T FuzzedDataProvider::ConsumeIntegral() { 196| 88| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 88| std::numeric_limits::max()); 198| 88|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIsEET_S1_S1_: 205| 88|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 88| static_assert(std::is_integral_v, "An integral type is required."); 207| 88| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 88| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 88] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 88| uint64_t range = static_cast(max) - static_cast(min); 214| 88| uint64_t result = 0; 215| 88| size_t offset = 0; 216| | 217| 149| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 120, False: 29] | Branch (217:43): [True: 120, False: 0] ------------------ 218| 120| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 61, False: 59] ------------------ 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| 61| --remaining_bytes_; 226| 61| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 61| offset += CHAR_BIT; 228| 61| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 88| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 88, False: 0] ------------------ 232| 88| result = result % (range + 1); 233| | 234| 88| return static_cast(static_cast(min) + result); 235| 88|} _ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v: 195| 99|template T FuzzedDataProvider::ConsumeIntegral() { 196| 99| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 99| std::numeric_limits::max()); 198| 99|} _ZN18FuzzedDataProviderC2EPKhm: 37| 1.87k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 1.38k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 1.38k| return 1 & ConsumeIntegral(); 291| 1.38k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 1.59k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 1.59k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 1.59k| std::numeric_limits::max()); 198| 1.59k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 1.59k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 1.59k| static_assert(std::is_integral_v, "An integral type is required."); 207| 1.59k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 1.59k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 1.59k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 1.59k| uint64_t range = static_cast(max) - static_cast(min); 214| 1.59k| uint64_t result = 0; 215| 1.59k| size_t offset = 0; 216| | 217| 2.10k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 1.59k, False: 504] | Branch (217:43): [True: 1.59k, False: 0] ------------------ 218| 1.59k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 504, False: 1.09k] ------------------ 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| 504| --remaining_bytes_; 226| 504| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 504| offset += CHAR_BIT; 228| 504| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 1.59k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 1.59k, False: 0] ------------------ 232| 1.59k| result = result % (range + 1); 233| | 234| 1.59k| return static_cast(static_cast(min) + result); 235| 1.59k|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm: 153| 2.82k|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) { 154| | // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\" 155| | // followed by anything else to the end of the string. As a result of this 156| | // logic, a fuzzer can insert characters into the string, and the string 157| | // will be lengthened to include those new characters, resulting in a more 158| | // stable fuzzer than picking the length of a string independently from 159| | // picking its contents. 160| 2.82k| std::string result; 161| | 162| | // Reserve the anticipated capacity to prevent several reallocations. 163| 2.82k| result.reserve(std::min(max_length, remaining_bytes_)); 164| 22.3k| for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) { ------------------ | Branch (164:22): [True: 22.2k, False: 143] | Branch (164:40): [True: 20.7k, False: 1.43k] ------------------ 165| 20.7k| char next = ConvertUnsignedToSigned(data_ptr_[0]); 166| 20.7k| Advance(1); 167| 20.7k| if (next == '\\' && remaining_bytes_ != 0) { ------------------ | Branch (167:9): [True: 1.55k, False: 19.2k] | Branch (167:25): [True: 1.55k, False: 6] ------------------ 168| 1.55k| next = ConvertUnsignedToSigned(data_ptr_[0]); 169| 1.55k| Advance(1); 170| 1.55k| if (next != '\\') ------------------ | Branch (170:11): [True: 1.25k, False: 300] ------------------ 171| 1.25k| break; 172| 1.55k| } 173| 19.5k| result += next; 174| 19.5k| } 175| | 176| 2.82k| result.shrink_to_fit(); 177| 2.82k| return result; 178| 2.82k|} _ZN18FuzzedDataProvider7AdvanceEm: 343| 22.3k|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 344| 22.3k| if (num_bytes > remaining_bytes_) ------------------ | Branch (344:7): [True: 0, False: 22.3k] ------------------ 345| 0| abort(); 346| | 347| 22.3k| data_ptr_ += num_bytes; 348| 22.3k| remaining_bytes_ -= num_bytes; 349| 22.3k|} _ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_: 378| 22.3k|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) { 379| 22.3k| static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types."); 380| 22.3k| static_assert(!std::numeric_limits::is_signed, 381| 22.3k| "Source type must be unsigned."); 382| | 383| | if constexpr (std::numeric_limits::is_modulo) 384| | return static_cast(value); 385| | 386| | // Avoid using implementation-defined unsigned to signed conversions. 387| | // To learn more, see https://stackoverflow.com/questions/13150449. 388| 22.3k| constexpr auto TS_max = static_cast(std::numeric_limits::max()); 389| 22.3k| if (value <= TS_max) { ------------------ | Branch (389:7): [True: 19.1k, False: 3.22k] ------------------ 390| 19.1k| return static_cast(value); 391| 19.1k| } else { 392| 3.22k| constexpr auto TS_min = std::numeric_limits::min(); 393| 3.22k| return TS_min + static_cast(value - TS_min); 394| 3.22k| } 395| 22.3k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 3.77k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 3.77k| static_assert(std::is_integral_v, "An integral type is required."); 207| 3.77k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 3.77k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 3.77k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 3.77k| uint64_t range = static_cast(max) - static_cast(min); 214| 3.77k| uint64_t result = 0; 215| 3.77k| size_t offset = 0; 216| | 217| 6.50k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 6.42k, False: 79] | Branch (217:43): [True: 4.41k, False: 2.01k] ------------------ 218| 4.41k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 2.72k, False: 1.68k] ------------------ 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.72k| --remaining_bytes_; 226| 2.72k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 2.72k| offset += CHAR_BIT; 228| 2.72k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 3.77k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 3.57k, False: 208] ------------------ 232| 3.57k| result = result % (range + 1); 233| | 234| 3.77k| return static_cast(static_cast(min) + result); 235| 3.77k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_: 205| 1.12k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 1.12k| static_assert(std::is_integral_v, "An integral type is required."); 207| 1.12k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 1.12k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 1.12k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 1.12k| uint64_t range = static_cast(max) - static_cast(min); 214| 1.12k| uint64_t result = 0; 215| 1.12k| size_t offset = 0; 216| | 217| 1.63k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 1.51k, False: 124] | Branch (217:43): [True: 1.51k, False: 0] ------------------ 218| 1.51k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 514, False: 1.00k] ------------------ 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| 514| --remaining_bytes_; 226| 514| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 514| offset += CHAR_BIT; 228| 514| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 1.12k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 1.12k, False: 0] ------------------ 232| 1.12k| result = result % (range + 1); 233| | 234| 1.12k| return static_cast(static_cast(min) + result); 235| 1.12k|} _ZN18FuzzedDataProvider15ConsumeIntegralIlEET_v: 195| 94|template T FuzzedDataProvider::ConsumeIntegral() { 196| 94| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 94| std::numeric_limits::max()); 198| 94|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIlEET_S1_S1_: 205| 94|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 94| static_assert(std::is_integral_v, "An integral type is required."); 207| 94| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 94| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 94] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 94| uint64_t range = static_cast(max) - static_cast(min); 214| 94| uint64_t result = 0; 215| 94| size_t offset = 0; 216| | 217| 270| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 251, False: 19] | Branch (217:43): [True: 251, False: 0] ------------------ 218| 251| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 176, False: 75] ------------------ 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| 176| --remaining_bytes_; 226| 176| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 176| offset += CHAR_BIT; 228| 176| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 94| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 0, False: 94] ------------------ 232| 0| result = result % (range + 1); 233| | 234| 94| return static_cast(static_cast(min) + result); 235| 94|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_: 205| 99|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 99| static_assert(std::is_integral_v, "An integral type is required."); 207| 99| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 99| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 99] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 99| uint64_t range = static_cast(max) - static_cast(min); 214| 99| uint64_t result = 0; 215| 99| size_t offset = 0; 216| | 217| 282| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 240, False: 42] | Branch (217:43): [True: 240, False: 0] ------------------ 218| 240| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 183, False: 57] ------------------ 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| 183| --remaining_bytes_; 226| 183| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 183| offset += CHAR_BIT; 228| 183| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 99| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 99, False: 0] ------------------ 232| 99| result = result % (range + 1); 233| | 234| 99| return static_cast(static_cast(min) + result); 235| 99|} LLVMFuzzerTestOneInput: 213| 1.87k|{ 214| 1.87k| test_one_input({data, size}); 215| 1.87k| return 0; 216| 1.87k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 1.87k|{ 85| 1.87k| CheckGlobals check{}; 86| 1.87k| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 1.87k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 1.87k|} _Z22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 24| 1.87k|{ 25| 1.87k| FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); 26| 1.87k| const std::string format_string = fuzzed_data_provider.ConsumeRandomLengthString(64); 27| | 28| 1.87k| const int digits_in_format_specifier = std::count_if(format_string.begin(), format_string.end(), IsDigit); 29| | 30| | // Avoid triggering the following crash bug: 31| | // * strprintf("%987654321000000:", 1); 32| | // 33| | // Avoid triggering the following OOM bug: 34| | // * strprintf("%.222222200000000$", 1.1); 35| | // 36| | // Upstream bug report: https://github.com/c42f/tinyformat/issues/70 37| 1.87k| if (format_string.find('%') != std::string::npos && digits_in_format_specifier >= 7) { ------------------ | Branch (37:9): [True: 1.48k, False: 390] | Branch (37:57): [True: 6, False: 1.47k] ------------------ 38| 6| return; 39| 6| } 40| | 41| | // Avoid triggering the following crash bug: 42| | // * strprintf("%1$*1$*", -11111111); 43| | // 44| | // Upstream bug report: https://github.com/c42f/tinyformat/issues/70 45| 1.86k| if (format_string.find('%') != std::string::npos && format_string.find('$') != std::string::npos && format_string.find('*') != std::string::npos && digits_in_format_specifier > 0) { ------------------ | Branch (45:9): [True: 1.47k, False: 390] | Branch (45:57): [True: 377, False: 1.09k] | Branch (45:105): [True: 8, False: 369] | Branch (45:153): [True: 4, False: 4] ------------------ 46| 4| return; 47| 4| } 48| | 49| | // Avoid triggering the following crash bug: 50| | // * strprintf("%.1s", (char*)nullptr); 51| | // 52| | // (void)strprintf(format_string, (char*)nullptr); 53| | // 54| | // Upstream bug report: https://github.com/c42f/tinyformat/issues/70 55| | 56| 1.86k| try { 57| 1.86k| CallOneOf( 58| 1.86k| fuzzed_data_provider, 59| 1.86k| [&] { 60| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32)); 61| 1.86k| }, 62| 1.86k| [&] { 63| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str()); 64| 1.86k| }, 65| 1.86k| [&] { 66| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 67| 1.86k| }, 68| 1.86k| [&] { 69| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 70| 1.86k| }, 71| 1.86k| [&] { 72| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 73| 1.86k| }, 74| 1.86k| [&] { 75| 1.86k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeBool()); 76| 1.86k| }); 77| 1.86k| } catch (const tinyformat::format_error&) { 78| 711| } 79| | 80| 1.86k| if (format_string.find('%') != std::string::npos && format_string.find('c') != std::string::npos) { ------------------ | Branch (80:9): [True: 1.47k, False: 390] | Branch (80:57): [True: 82, False: 1.39k] ------------------ 81| | // Avoid triggering the following: 82| | // * strprintf("%c", 1.31783e+38); 83| | // tinyformat.h:244:36: runtime error: 1.31783e+38 is outside the range of representable values of type 'char' 84| 82| return; 85| 82| } 86| | 87| 1.78k| if (format_string.find('%') != std::string::npos && format_string.find('*') != std::string::npos) { ------------------ | Branch (87:9): [True: 1.39k, False: 390] | Branch (87:57): [True: 71, False: 1.31k] ------------------ 88| | // Avoid triggering the following: 89| | // * strprintf("%*", -2.33527e+38); 90| | // tinyformat.h:283:65: runtime error: -2.33527e+38 is outside the range of representable values of type 'int' 91| | // * strprintf("%*", -2147483648); 92| | // tinyformat.h:763:25: runtime error: negation of -2147483648 cannot be represented in type 'int'; cast to an unsigned type to negate this value to itself 93| 71| return; 94| 71| } 95| | 96| 1.70k| try { 97| 1.70k| CallOneOf( 98| 1.70k| fuzzed_data_provider, 99| 1.70k| [&] { 100| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeFloatingPoint()); 101| 1.70k| }, 102| 1.70k| [&] { 103| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeFloatingPoint()); 104| 1.70k| }, 105| 1.70k| [&] { 106| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 107| 1.70k| }, 108| 1.70k| [&] { 109| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 110| 1.70k| }, 111| 1.70k| [&] { 112| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 113| 1.70k| }, 114| 1.70k| [&] { 115| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 116| 1.70k| }, 117| 1.70k| [&] { 118| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 119| 1.70k| }, 120| 1.70k| [&] { 121| 1.70k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 122| 1.70k| }); 123| 1.70k| } catch (const tinyformat::format_error&) { 124| 639| } 125| 1.70k|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 59| 781| [&] { 60| 781| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32)); 61| 781| }, _Z8fuzz_fmtIJNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEEEvRKS6_DpRKT_: 19| 781|{ 20| 781| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 781|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv: 62| 175| [&] { 63| 175| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeRandomLengthString(32).c_str()); 64| 175| }, _Z8fuzz_fmtIJPKcEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEDpRKT_: 19| 175|{ 20| 175| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 175|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv: 65| 214| [&] { 66| 214| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 67| 214| }, _Z8fuzz_fmtIJaEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 214|{ 20| 214| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 214|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv: 68| 214| [&] { 69| 214| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 70| 214| }, _Z8fuzz_fmtIJhEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 214|{ 20| 214| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 214|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv: 71| 216| [&] { 72| 216| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 73| 216| }, _Z8fuzz_fmtIJcEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 216|{ 20| 216| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 216|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv: 74| 262| [&] { 75| 262| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeBool()); 76| 262| }); _Z8fuzz_fmtIJbEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 262|{ 20| 262| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 262|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv: 99| 1.01k| [&] { 100| 1.01k| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeFloatingPoint()); 101| 1.01k| }, _Z8fuzz_fmtIJfEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 1.01k|{ 20| 1.01k| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 1.01k|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_7clEv: 102| 107| [&] { 103| 107| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeFloatingPoint()); 104| 107| }, _Z8fuzz_fmtIJdEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 107|{ 20| 107| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 107|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_8clEv: 105| 88| [&] { 106| 88| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 107| 88| }, _Z8fuzz_fmtIJsEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 88|{ 20| 88| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 88|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_9clEv: 108| 96| [&] { 109| 96| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 110| 96| }, _Z8fuzz_fmtIJtEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 96|{ 20| 96| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 96|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_10clEv: 111| 99| [&] { 112| 99| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 113| 99| }, _Z8fuzz_fmtIJiEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 99|{ 20| 99| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 99|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_11clEv: 114| 109| [&] { 115| 109| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 116| 109| }, _Z8fuzz_fmtIJjEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 109|{ 20| 109| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 109|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_12clEv: 117| 94| [&] { 118| 94| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 119| 94| }, _Z8fuzz_fmtIJlEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 94|{ 20| 94| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 94|} strprintf.cpp:_ZZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK4$_13clEv: 120| 101| [&] { 121| 101| fuzz_fmt(format_string, fuzzed_data_provider.ConsumeIntegral()); 122| 101| }); _Z8fuzz_fmtIJmEEvRKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEDpRKT_: 19| 101|{ 20| 101| (void)tfm::format(tfm::RuntimeFormat{fmt}, args...); 21| 101|} strprintf.cpp:_Z9CallOneOfIJZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_0Z22str_printf_fuzz_targetS3_E3$_1Z22str_printf_fuzz_targetS3_E3$_2Z22str_printf_fuzz_targetS3_E3$_3Z22str_printf_fuzz_targetS3_E3$_4Z22str_printf_fuzz_targetS3_E3$_5EEmR18FuzzedDataProviderDpT_: 38| 1.86k|{ 39| 1.86k| constexpr size_t call_size{sizeof...(callables)}; 40| 1.86k| static_assert(call_size >= 1); 41| 1.86k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 1.86k| size_t i{0}; 44| 11.1k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 781, False: 1.08k] | Branch (44:7): [True: 175, False: 1.68k] | Branch (44:7): [True: 214, False: 1.64k] | Branch (44:7): [True: 214, False: 1.64k] | Branch (44:7): [True: 216, False: 1.64k] | Branch (44:7): [True: 262, False: 1.60k] ------------------ 45| 1.86k| return call_size; 46| 1.86k|} strprintf.cpp:_Z9CallOneOfIJZ22str_printf_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEE3$_6Z22str_printf_fuzz_targetS3_E3$_7Z22str_printf_fuzz_targetS3_E3$_8Z22str_printf_fuzz_targetS3_E3$_9Z22str_printf_fuzz_targetS3_E4$_10Z22str_printf_fuzz_targetS3_E4$_11Z22str_printf_fuzz_targetS3_E4$_12Z22str_printf_fuzz_targetS3_E4$_13EEmR18FuzzedDataProviderDpT_: 38| 1.70k|{ 39| 1.70k| constexpr size_t call_size{sizeof...(callables)}; 40| 1.70k| static_assert(call_size >= 1); 41| 1.70k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 42| | 43| 1.70k| size_t i{0}; 44| 13.6k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (44:7): [True: 1.01k, False: 694] | Branch (44:7): [True: 107, False: 1.60k] | Branch (44:7): [True: 88, False: 1.62k] | Branch (44:7): [True: 96, False: 1.61k] | Branch (44:7): [True: 99, False: 1.61k] | Branch (44:7): [True: 109, False: 1.60k] | Branch (44:7): [True: 94, False: 1.61k] | Branch (44:7): [True: 101, False: 1.60k] ------------------ 45| 1.70k| return call_size; 46| 1.70k|} _ZN12CheckGlobalsC2Ev: 59| 1.87k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 1.87k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 1.87k| { 18| 1.87k| g_used_g_prng = false; 19| 1.87k| g_seeded_g_prng_zero = false; 20| 1.87k| g_used_system_time = false; 21| 1.87k| SetMockTime(0s); 22| 1.87k| MockableSteadyClock::ClearMockTime(); 23| 1.87k| } _ZN16CheckGlobalsImplD2Ev: 25| 1.87k| { 26| 1.87k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 1.87k] | 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.87k| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 1.87k] ------------------ 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.87k| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN10tinyformat6formatIJaEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 214|{ 1089| 214| std::ostringstream oss; 1090| 214| format(oss, fmt, args...); 1091| 214| return oss.str(); 1092| 214|} _ZN10tinyformat6formatIJaEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 214|{ 1081| 214| vformat(out, fmt, makeFormatList(args...)); 1082| 214|} _ZN10tinyformat14makeFormatListIJaEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 214|{ 1045| 214| return detail::FormatListN(args...); 1046| 214|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJaEEEDpRKT_: 990| 214| : FormatList(&m_formatterStore[0], N), 991| 214| m_formatterStore { FormatArg(args)... } 992| 214| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IaEERKT_: 534| 214| : m_value(static_cast(&value)), 535| 214| m_formatImpl(&formatImpl), 536| 214| m_toIntImpl(&toIntImpl) 537| 214| { } _ZN10tinyformat6detail9FormatArg10formatImplIaEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 240| { 559| 240| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 240| } _ZN10tinyformat11formatValueERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcS7_ia: 385| 240| const char* fmtEnd, int /**/, charType value) \ 386| 240|{ \ 387| 240| switch (*(fmtEnd-1)) { \ 388| 102| case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \ ------------------ | Branch (388:9): [True: 14, False: 226] | Branch (388:19): [True: 29, False: 211] | Branch (388:29): [True: 13, False: 227] | Branch (388:39): [True: 22, False: 218] | Branch (388:49): [True: 10, False: 230] | Branch (388:59): [True: 14, False: 226] ------------------ 389| 102| out << static_cast(value); break; \ 390| 138| default: \ ------------------ | Branch (390:9): [True: 138, False: 102] ------------------ 391| 138| out << value; break; \ 392| 240| } \ 393| 240|} _ZN10tinyformat6detail9FormatArg9toIntImplIaEEiPKv: 564| 10| { 565| 10| return convertToInt::invoke(*static_cast(value)); 566| 10| } _ZN10tinyformat6detail12convertToIntIaLb1EE6invokeERKa: 303| 10| static int invoke(const T& value) { return static_cast(value); } _ZN10tinyformat6formatIJfEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 1.01k|{ 1089| 1.01k| std::ostringstream oss; 1090| 1.01k| format(oss, fmt, args...); 1091| 1.01k| return oss.str(); 1092| 1.01k|} _ZN10tinyformat6formatIJfEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 1.01k|{ 1081| 1.01k| vformat(out, fmt, makeFormatList(args...)); 1082| 1.01k|} _ZN10tinyformat14makeFormatListIJfEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 1.01k|{ 1045| 1.01k| return detail::FormatListN(args...); 1046| 1.01k|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJfEEEDpRKT_: 990| 1.01k| : FormatList(&m_formatterStore[0], N), 991| 1.01k| m_formatterStore { FormatArg(args)... } 992| 1.01k| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6formatIJsEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 88|{ 1089| 88| std::ostringstream oss; 1090| 88| format(oss, fmt, args...); 1091| 88| return oss.str(); 1092| 88|} _ZN10tinyformat6formatIJsEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 88|{ 1081| 88| vformat(out, fmt, makeFormatList(args...)); 1082| 88|} _ZN10tinyformat14makeFormatListIJsEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 88|{ 1045| 88| return detail::FormatListN(args...); 1046| 88|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJsEEEDpRKT_: 990| 88| : FormatList(&m_formatterStore[0], N), 991| 88| m_formatterStore { FormatArg(args)... } 992| 88| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IsEERKT_: 534| 88| : m_value(static_cast(&value)), 535| 88| m_formatImpl(&formatImpl), 536| 88| m_toIntImpl(&toIntImpl) 537| 88| { } _ZN10tinyformat6detail9FormatArg10formatImplIsEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 91| { 559| 91| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 91| } _ZN10tinyformat11formatValueIsEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 91|{ 352| 91|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 91| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 91| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 91|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 91| const bool canConvertToChar = detail::is_convertible::value; 364| 91| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 91| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 91, Folded] | Branch (365:29): [True: 0, False: 91] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 91| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 91] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 91| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 51, False: 40] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 51| detail::formatTruncated(out, value, ntrunc); 376| 51| } 377| 40| else 378| 40| out << value; 379| 91|} _ZN10tinyformat6detail15formatTruncatedIsEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 51|{ 310| 51| std::ostringstream tmp; 311| 51| tmp << value; 312| 51| std::string result = tmp.str(); 313| 51| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 51|} _ZN10tinyformat6formatIJiEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 99|{ 1089| 99| std::ostringstream oss; 1090| 99| format(oss, fmt, args...); 1091| 99| return oss.str(); 1092| 99|} _ZN10tinyformat6formatIJiEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 99|{ 1081| 99| vformat(out, fmt, makeFormatList(args...)); 1082| 99|} _ZN10tinyformat14makeFormatListIJiEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 99|{ 1045| 99| return detail::FormatListN(args...); 1046| 99|} _ZN10tinyformat6formatIJcEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 216|{ 1089| 216| std::ostringstream oss; 1090| 216| format(oss, fmt, args...); 1091| 216| return oss.str(); 1092| 216|} _ZN10tinyformat6formatIJcEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 216|{ 1081| 216| vformat(out, fmt, makeFormatList(args...)); 1082| 216|} _ZN10tinyformat14makeFormatListIJcEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 216|{ 1045| 216| return detail::FormatListN(args...); 1046| 216|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJcEEEDpRKT_: 990| 216| : FormatList(&m_formatterStore[0], N), 991| 216| m_formatterStore { FormatArg(args)... } 992| 216| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IcEERKT_: 534| 216| : m_value(static_cast(&value)), 535| 216| m_formatImpl(&formatImpl), 536| 216| m_toIntImpl(&toIntImpl) 537| 216| { } _ZN10tinyformat6detail9FormatArg10formatImplIcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 259| { 559| 259| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 259| } _ZN10tinyformat11formatValueERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcS7_ic: 385| 259| const char* fmtEnd, int /**/, charType value) \ 386| 259|{ \ 387| 259| switch (*(fmtEnd-1)) { \ 388| 100| case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \ ------------------ | Branch (388:9): [True: 17, False: 242] | Branch (388:19): [True: 20, False: 239] | Branch (388:29): [True: 14, False: 245] | Branch (388:39): [True: 16, False: 243] | Branch (388:49): [True: 20, False: 239] | Branch (388:59): [True: 13, False: 246] ------------------ 389| 100| out << static_cast(value); break; \ 390| 159| default: \ ------------------ | Branch (390:9): [True: 159, False: 100] ------------------ 391| 159| out << value; break; \ 392| 259| } \ 393| 259|} _ZN10tinyformat6detail9FormatArg9toIntImplIcEEiPKv: 564| 9| { 565| 9| return convertToInt::invoke(*static_cast(value)); 566| 9| } _ZN10tinyformat6detail12convertToIntIcLb1EE6invokeERKc: 303| 9| static int invoke(const T& value) { return static_cast(value); } _ZN10tinyformat6formatIJhEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 214|{ 1089| 214| std::ostringstream oss; 1090| 214| format(oss, fmt, args...); 1091| 214| return oss.str(); 1092| 214|} _ZN10tinyformat6formatIJhEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 214|{ 1081| 214| vformat(out, fmt, makeFormatList(args...)); 1082| 214|} _ZN10tinyformat14makeFormatListIJhEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 214|{ 1045| 214| return detail::FormatListN(args...); 1046| 214|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJhEEEDpRKT_: 990| 214| : FormatList(&m_formatterStore[0], N), 991| 214| m_formatterStore { FormatArg(args)... } 992| 214| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6formatIJbEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 262|{ 1089| 262| std::ostringstream oss; 1090| 262| format(oss, fmt, args...); 1091| 262| return oss.str(); 1092| 262|} _ZN10tinyformat6formatIJbEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 262|{ 1081| 262| vformat(out, fmt, makeFormatList(args...)); 1082| 262|} _ZN10tinyformat14makeFormatListIJbEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 262|{ 1045| 262| return detail::FormatListN(args...); 1046| 262|} _ZN10tinyformat6detail9FormatArg10formatImplIbEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 288| { 559| 288| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 288| } _ZN10tinyformat11formatValueIbEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 288|{ 352| 288|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 288| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 288| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 288|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 288| const bool canConvertToChar = detail::is_convertible::value; 364| 288| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 288| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 288, Folded] | Branch (365:29): [True: 11, False: 277] ------------------ 366| 11| detail::formatValueAsType::invoke(out, value); 367| 277| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 277] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 277| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 179, False: 98] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 179| detail::formatTruncated(out, value, ntrunc); 376| 179| } 377| 98| else 378| 98| out << value; 379| 288|} _ZN10tinyformat6detail17formatValueAsTypeIbcLb1EE6invokeERNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEERKb: 264| 11| { out << static_cast(value); } _ZN10tinyformat6detail15formatTruncatedIbEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 179|{ 310| 179| std::ostringstream tmp; 311| 179| tmp << value; 312| 179| std::string result = tmp.str(); 313| 179| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 179|} _ZN10tinyformat6detail9FormatArg9toIntImplIbEEiPKv: 564| 1| { 565| 1| return convertToInt::invoke(*static_cast(value)); 566| 1| } _ZN10tinyformat6detail12convertToIntIbLb1EE6invokeERKb: 303| 1| static int invoke(const T& value) { return static_cast(value); } _ZN10tinyformat6formatIJjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 109|{ 1089| 109| std::ostringstream oss; 1090| 109| format(oss, fmt, args...); 1091| 109| return oss.str(); 1092| 109|} _ZN10tinyformat6formatIJjEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 109|{ 1081| 109| vformat(out, fmt, makeFormatList(args...)); 1082| 109|} _ZN10tinyformat14makeFormatListIJjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 109|{ 1045| 109| return detail::FormatListN(args...); 1046| 109|} _ZN10tinyformat6detail9FormatArg10formatImplIjEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 89| { 559| 89| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 89| } _ZN10tinyformat11formatValueIjEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 89|{ 352| 89|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 89| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 89| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 89|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 89| const bool canConvertToChar = detail::is_convertible::value; 364| 89| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 89| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 89, Folded] | Branch (365:29): [True: 0, False: 89] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 89| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 89] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 89| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 48, False: 41] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 48| detail::formatTruncated(out, value, ntrunc); 376| 48| } 377| 41| else 378| 41| out << value; 379| 89|} _ZN10tinyformat6detail15formatTruncatedIjEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 48|{ 310| 48| std::ostringstream tmp; 311| 48| tmp << value; 312| 48| std::string result = tmp.str(); 313| 48| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 48|} _ZN10tinyformat6detail9FormatArgC2IhEERKT_: 534| 214| : m_value(static_cast(&value)), 535| 214| m_formatImpl(&formatImpl), 536| 214| m_toIntImpl(&toIntImpl) 537| 214| { } _ZN10tinyformat6detail9FormatArg10formatImplIhEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 250| { 559| 250| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 250| } _ZN10tinyformat11formatValueERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcS7_ih: 385| 250| const char* fmtEnd, int /**/, charType value) \ 386| 250|{ \ 387| 250| switch (*(fmtEnd-1)) { \ 388| 89| case 'u': case 'd': case 'i': case 'o': case 'X': case 'x': \ ------------------ | Branch (388:9): [True: 16, False: 234] | Branch (388:19): [True: 24, False: 226] | Branch (388:29): [True: 13, False: 237] | Branch (388:39): [True: 13, False: 237] | Branch (388:49): [True: 12, False: 238] | Branch (388:59): [True: 11, False: 239] ------------------ 389| 89| out << static_cast(value); break; \ 390| 161| default: \ ------------------ | Branch (390:9): [True: 161, False: 89] ------------------ 391| 161| out << value; break; \ 392| 250| } \ 393| 250|} _ZN10tinyformat6detail9FormatArg9toIntImplIhEEiPKv: 564| 1| { 565| 1| return convertToInt::invoke(*static_cast(value)); 566| 1| } _ZN10tinyformat6detail12convertToIntIhLb1EE6invokeERKh: 303| 1| static int invoke(const T& value) { return static_cast(value); } _ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 93| { 559| 93| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 93| } _ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 93|{ 352| 93|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 93| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 93| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 93|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 93| const bool canConvertToChar = detail::is_convertible::value; 364| 93| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 93| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 93, Folded] | Branch (365:29): [True: 0, False: 93] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 93| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 93] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 93| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 50, False: 43] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 50| detail::formatTruncated(out, value, ntrunc); 376| 50| } 377| 43| else 378| 43| out << value; 379| 93|} _ZN10tinyformat6detail15formatTruncatedIlEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 50|{ 310| 50| std::ostringstream tmp; 311| 50| tmp << value; 312| 50| std::string result = tmp.str(); 313| 50| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 50|} _ZN10tinyformat6formatIJtEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 96|{ 1089| 96| std::ostringstream oss; 1090| 96| format(oss, fmt, args...); 1091| 96| return oss.str(); 1092| 96|} _ZN10tinyformat6formatIJtEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 96|{ 1081| 96| vformat(out, fmt, makeFormatList(args...)); 1082| 96|} _ZN10tinyformat14makeFormatListIJtEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 96|{ 1045| 96| return detail::FormatListN(args...); 1046| 96|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJtEEEDpRKT_: 990| 96| : FormatList(&m_formatterStore[0], N), 991| 96| m_formatterStore { FormatArg(args)... } 992| 96| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2ItEERKT_: 534| 96| : m_value(static_cast(&value)), 535| 96| m_formatImpl(&formatImpl), 536| 96| m_toIntImpl(&toIntImpl) 537| 96| { } _ZN10tinyformat6detail9FormatArg10formatImplItEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 88| { 559| 88| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 88| } _ZN10tinyformat11formatValueItEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 88|{ 352| 88|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 88| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 88| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 88|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 88| const bool canConvertToChar = detail::is_convertible::value; 364| 88| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 88| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 88, Folded] | Branch (365:29): [True: 0, False: 88] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 88| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 88] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 88| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 44, False: 44] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 44| detail::formatTruncated(out, value, ntrunc); 376| 44| } 377| 44| else 378| 44| out << value; 379| 88|} _ZN10tinyformat6detail15formatTruncatedItEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 44|{ 310| 44| std::ostringstream tmp; 311| 44| tmp << value; 312| 44| std::string result = tmp.str(); 313| 44| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 44|} _ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv: 558| 684| { 559| 684| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 684| } _ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_: 351| 684|{ 352| 684|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 684| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 684| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 684|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 684| const bool canConvertToChar = detail::is_convertible::value; 364| 684| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 684| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [Folded, False: 684] | Branch (365:29): [True: 0, False: 0] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 684| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 684] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 684| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 126, False: 558] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 126| detail::formatTruncated(out, value, ntrunc); 376| 126| } 377| 558| else 378| 558| out << value; 379| 684|} _ZN10tinyformat6detail15formatTruncatedINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEEvRNS2_13basic_ostreamIcS5_EERKT_i: 309| 126|{ 310| 126| std::ostringstream tmp; 311| 126| tmp << value; 312| 126| std::string result = tmp.str(); 313| 126| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 126|} _ZN10tinyformat6detail9FormatArg9toIntImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEiPKv: 564| 8| { 565| 8| return convertToInt::invoke(*static_cast(value)); 566| 8| } _ZN10tinyformat6detail12convertToIntINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEELb0EE6invokeERKS8_: 293| 8| { 294| 8| TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to " ------------------ | | 135| 8|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 295| 8| "integer for use as variable width or precision"); 296| 0| return 0; 297| 8| } _ZN10tinyformat6formatIJPKcEEENSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 175|{ 1089| 175| std::ostringstream oss; 1090| 175| format(oss, fmt, args...); 1091| 175| return oss.str(); 1092| 175|} _ZN10tinyformat6formatIJPKcEEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 175|{ 1081| 175| vformat(out, fmt, makeFormatList(args...)); 1082| 175|} _ZN10tinyformat14makeFormatListIJPKcEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 175|{ 1045| 175| return detail::FormatListN(args...); 1046| 175|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJPKcEEEDpRKT_: 990| 175| : FormatList(&m_formatterStore[0], N), 991| 175| m_formatterStore { FormatArg(args)... } 992| 175| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IPKcEERKT_: 534| 175| : m_value(static_cast(&value)), 535| 175| m_formatImpl(&formatImpl), 536| 175| m_toIntImpl(&toIntImpl) 537| 175| { } _ZN10tinyformat6detail9FormatArg10formatImplIPKcEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEES4_S4_iPKv: 558| 149| { 559| 149| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 149| } _ZN10tinyformat11formatValueIPKcEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEES2_S2_iRKT_: 351| 149|{ 352| 149|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 149| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 149| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 149|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 149| const bool canConvertToChar = detail::is_convertible::value; 364| 149| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 149| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [Folded, False: 149] | Branch (365:29): [True: 0, False: 0] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 149| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [True: 149, Folded] | Branch (367:37): [True: 12, False: 137] ------------------ 368| 12| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 137| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 63, False: 74] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 63| detail::formatTruncated(out, value, ntrunc); 376| 63| } 377| 74| else 378| 74| out << value; 379| 149|} _ZN10tinyformat6detail17formatValueAsTypeIPKcPKvLb1EE6invokeERNSt3__113basic_ostreamIcNS7_11char_traitsIcEEEERKS3_: 264| 12| { out << static_cast(value); } _ZN10tinyformat6detail9FormatArg9toIntImplIPKcEEiPKv: 564| 3| { 565| 3| return convertToInt::invoke(*static_cast(value)); 566| 3| } _ZN10tinyformat6detail12convertToIntIPKcLb0EE6invokeERKS3_: 293| 3| { 294| 3| TINYFORMAT_ERROR("tinyformat: Cannot convert from argument type to " ------------------ | | 135| 3|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 295| 3| "integer for use as variable width or precision"); 296| 0| return 0; 297| 3| } _ZN10tinyformat6detail9FormatArgC2IdEERKT_: 534| 107| : m_value(static_cast(&value)), 535| 107| m_formatImpl(&formatImpl), 536| 107| m_toIntImpl(&toIntImpl) 537| 107| { } _ZN10tinyformat6detail9FormatArg10formatImplIdEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 106| { 559| 106| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 106| } _ZN10tinyformat11formatValueIdEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 106|{ 352| 106|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 106| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 106| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 106|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 106| const bool canConvertToChar = detail::is_convertible::value; 364| 106| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 106| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 106, Folded] | Branch (365:29): [True: 0, False: 106] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 106| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 106] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 106| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 64, False: 42] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 64| detail::formatTruncated(out, value, ntrunc); 376| 64| } 377| 42| else 378| 42| out << value; 379| 106|} _ZN10tinyformat6detail15formatTruncatedIdEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 64|{ 310| 64| std::ostringstream tmp; 311| 64| tmp << value; 312| 64| std::string result = tmp.str(); 313| 64| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 64|} _ZN10tinyformat13RuntimeFormatC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 186| 3.57k| explicit RuntimeFormat(LIFETIMEBOUND const std::string& str) : fmt{str} {} _ZN10tinyformat17FormatStringCheckILj1EEC2ERKNS_13RuntimeFormatE: 195| 3.57k| FormatStringCheck(LIFETIMEBOUND const RuntimeFormat& run) : fmt{run.fmt.c_str()} {} _ZN10tinyformat6formatIJlEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 94|{ 1089| 94| std::ostringstream oss; 1090| 94| format(oss, fmt, args...); 1091| 94| return oss.str(); 1092| 94|} _ZN10tinyformat6formatIJlEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 94|{ 1081| 94| vformat(out, fmt, makeFormatList(args...)); 1082| 94|} _ZN10tinyformat14makeFormatListIJlEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 94|{ 1045| 94| return detail::FormatListN(args...); 1046| 94|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJlEEEDpRKT_: 990| 94| : FormatList(&m_formatterStore[0], N), 991| 94| m_formatterStore { FormatArg(args)... } 992| 94| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6formatIJdEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 107|{ 1089| 107| std::ostringstream oss; 1090| 107| format(oss, fmt, args...); 1091| 107| return oss.str(); 1092| 107|} _ZN10tinyformat6formatIJdEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 107|{ 1081| 107| vformat(out, fmt, makeFormatList(args...)); 1082| 107|} _ZN10tinyformat14makeFormatListIJdEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 107|{ 1045| 107| return detail::FormatListN(args...); 1046| 107|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJdEEEDpRKT_: 990| 107| : FormatList(&m_formatterStore[0], N), 991| 107| m_formatterStore { FormatArg(args)... } 992| 107| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail11FormatListNILi1EEC2IJiEEEDpRKT_: 990| 99| : FormatList(&m_formatterStore[0], N), 991| 99| m_formatterStore { FormatArg(args)... } 992| 99| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IfEERKT_: 534| 1.01k| : m_value(static_cast(&value)), 535| 1.01k| m_formatImpl(&formatImpl), 536| 1.01k| m_toIntImpl(&toIntImpl) 537| 1.01k| { } _ZN10tinyformat6detail9FormatArg10formatImplIfEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 1.05k| { 559| 1.05k| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 1.05k| } _ZN10tinyformat11formatValueIfEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 1.05k|{ 352| 1.05k|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 1.05k| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 1.05k| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 1.05k|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 1.05k| const bool canConvertToChar = detail::is_convertible::value; 364| 1.05k| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 1.05k| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 1.05k, Folded] | Branch (365:29): [True: 0, False: 1.05k] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 1.05k| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 1.05k] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 1.05k| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 219, False: 832] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 219| detail::formatTruncated(out, value, ntrunc); 376| 219| } 377| 832| else 378| 832| out << value; 379| 1.05k|} _ZN10tinyformat6detail15formatTruncatedIfEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 219|{ 310| 219| std::ostringstream tmp; 311| 219| tmp << value; 312| 219| std::string result = tmp.str(); 313| 219| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 219|} _ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEES7_NS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 781|{ 1089| 781| std::ostringstream oss; 1090| 781| format(oss, fmt, args...); 1091| 781| return oss.str(); 1092| 781|} _ZN10tinyformat6formatIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEEvRNS1_13basic_ostreamIcS4_EENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 781|{ 1081| 781| vformat(out, fmt, makeFormatList(args...)); 1082| 781|} _ZN10tinyformat14makeFormatListIJNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 781|{ 1045| 781| return detail::FormatListN(args...); 1046| 781|} _ZN10tinyformat17FormatStringCheckILj1EEcvPKcEv: 197| 3.57k| operator const char*() { return fmt; } _ZN10tinyformat6detail15formatTruncatedERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKci: 316| 63|inline void formatTruncated(std::ostream& out, type* value, int ntrunc) \ 317| 63|{ \ 318| 63| std::streamsize len = 0; \ 319| 213| while (len < ntrunc && value[len] != 0) \ ------------------ | Branch (319:12): [True: 193, False: 20] | Branch (319:28): [True: 150, False: 43] ------------------ 320| 150| ++len; \ 321| 63| out.write(value, len); \ 322| 63|} _ZN10tinyformat12format_errorC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 205| 1.35k| explicit format_error(const std::string &what): std::runtime_error(what) { 206| 1.35k| } _ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i: 541| 3.58k| { 542| 3.58k| TINYFORMAT_ASSERT(m_value); ------------------ | | 153| 3.58k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (542:13): [True: 3.58k, False: 0] ------------------ 543| 3.58k| TINYFORMAT_ASSERT(m_formatImpl); ------------------ | | 153| 3.58k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (543:13): [True: 3.58k, False: 0] ------------------ 544| 3.58k| m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); 545| 3.58k| } _ZNK10tinyformat6detail9FormatArg5toIntEv: 548| 32| { 549| 32| TINYFORMAT_ASSERT(m_value); ------------------ | | 153| 32|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (549:13): [True: 32, False: 0] ------------------ 550| 32| TINYFORMAT_ASSERT(m_toIntImpl); ------------------ | | 153| 32|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (550:13): [True: 32, False: 0] ------------------ 551| 32| return m_toIntImpl(m_value); 552| 32| } _ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi: 966| 3.57k| : m_args(args), m_N(N) { } _ZN10tinyformat6detail18parseIntAndAdvanceERPKc: 578| 2.90k|{ 579| 2.90k| int i = 0; 580| 9.24k| for (;*c >= '0' && *c <= '9'; ++c) ------------------ | Branch (580:11): [True: 7.40k, False: 1.83k] | Branch (580:24): [True: 6.34k, False: 1.06k] ------------------ 581| 6.34k| i = 10*i + (*c - '0'); 582| 2.90k| return i; 583| 2.90k|} _ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i: 593| 4.88k|{ 594| 4.88k| if (*c >= '0' && *c <= '9') { ------------------ | Branch (594:9): [True: 2.99k, False: 1.88k] | Branch (594:22): [True: 1.06k, False: 1.93k] ------------------ 595| 1.06k| n = parseIntAndAdvance(c); 596| 1.06k| } 597| 3.82k| else if (*c == '*') { ------------------ | Branch (597:14): [True: 34, False: 3.78k] ------------------ 598| 34| ++c; 599| 34| n = 0; 600| 34| if (positionalMode) { ------------------ | Branch (600:13): [True: 0, False: 34] ------------------ 601| 0| int pos = parseIntAndAdvance(c) - 1; 602| 0| if (*c != '$') ------------------ | Branch (602:17): [True: 0, False: 0] ------------------ 603| 0| TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 604| 0| if (pos >= 0 && pos < numArgs) ------------------ | Branch (604:17): [True: 0, False: 0] | Branch (604:29): [True: 0, False: 0] ------------------ 605| 0| n = args[pos].toInt(); 606| 0| else 607| 0| TINYFORMAT_ERROR("tinyformat: Positional argument out of range"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 608| 0| ++c; 609| 0| } 610| 34| else { 611| 34| if (argIndex < numArgs) ------------------ | Branch (611:17): [True: 32, False: 2] ------------------ 612| 32| n = args[argIndex++].toInt(); 613| 2| else 614| 2| TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision"); ------------------ | | 135| 2|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 615| 34| } 616| 34| } 617| 3.78k| else { 618| 3.78k| return false; 619| 3.78k| } 620| 1.09k| return true; 621| 4.88k|} _ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc: 629| 7.15k|{ 630| 7.15k| const char* c = fmt; 631| 11.6k| for (;; ++c) { 632| 11.6k| if (*c == '\0') { ------------------ | Branch (632:13): [True: 3.02k, False: 8.62k] ------------------ 633| 3.02k| out.write(fmt, c - fmt); 634| 3.02k| return c; 635| 3.02k| } 636| 8.62k| else if (*c == '%') { ------------------ | Branch (636:18): [True: 4.23k, False: 4.38k] ------------------ 637| 4.23k| out.write(fmt, c - fmt); 638| 4.23k| if (*(c+1) != '%') ------------------ | Branch (638:17): [True: 4.12k, False: 113] ------------------ 639| 4.12k| return c; 640| | // for "%%", tack trailing % onto next literal section. 641| 113| fmt = ++c; 642| 113| } 643| 11.6k| } 644| 7.15k|} _ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i: 685| 4.12k|{ 686| 4.12k| TINYFORMAT_ASSERT(*fmtStart == '%'); ------------------ | | 153| 4.12k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (686:5): [True: 4.12k, False: 0] ------------------ 687| | // Reset stream state to defaults. 688| 4.12k| out.width(0); 689| 4.12k| out.precision(6); 690| 4.12k| out.fill(' '); 691| | // Reset most flags; ignore irrelevant unitbuf & skipws. 692| 4.12k| out.unsetf(std::ios::adjustfield | std::ios::basefield | 693| 4.12k| std::ios::floatfield | std::ios::showbase | std::ios::boolalpha | 694| 4.12k| std::ios::showpoint | std::ios::showpos | std::ios::uppercase); 695| 4.12k| bool precisionSet = false; 696| 4.12k| bool widthSet = false; 697| 4.12k| int widthExtra = 0; 698| 4.12k| const char* c = fmtStart + 1; 699| | 700| | // 1) Parse an argument index (if followed by '$') or a width possibly 701| | // preceded with '0' flag. 702| 4.12k| if (*c >= '0' && *c <= '9') { ------------------ | Branch (702:9): [True: 2.51k, False: 1.61k] | Branch (702:22): [True: 1.84k, False: 669] ------------------ 703| 1.84k| const char tmpc = *c; 704| 1.84k| int value = parseIntAndAdvance(c); 705| 1.84k| if (*c == '$') { ------------------ | Branch (705:13): [True: 1.32k, False: 521] ------------------ 706| | // value is an argument index 707| 1.32k| if (value > 0 && value <= numArgs) ------------------ | Branch (707:17): [True: 1.31k, False: 7] | Branch (707:30): [True: 1.25k, False: 65] ------------------ 708| 1.25k| argIndex = value - 1; 709| 72| else 710| 72| TINYFORMAT_ERROR("tinyformat: Positional argument out of range"); ------------------ | | 135| 72|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 711| 1.25k| ++c; 712| 1.25k| positionalMode = true; 713| 1.25k| } 714| 521| else if (positionalMode) { ------------------ | Branch (714:18): [True: 14, False: 507] ------------------ 715| 14| TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one"); ------------------ | | 135| 14|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 716| 14| } 717| 507| else { 718| 507| if (tmpc == '0') { ------------------ | Branch (718:17): [True: 28, False: 479] ------------------ 719| | // Use internal padding so that numeric values are 720| | // formatted correctly, eg -00010 rather than 000-10 721| 28| out.fill('0'); 722| 28| out.setf(std::ios::internal, std::ios::adjustfield); 723| 28| } 724| 507| if (value != 0) { ------------------ | Branch (724:17): [True: 479, False: 28] ------------------ 725| | // Nonzero value means that we parsed width. 726| 479| widthSet = true; 727| 479| out.width(value); 728| 479| } 729| 507| } 730| 1.84k| } 731| 2.28k| else if (positionalMode) { ------------------ | Branch (731:14): [True: 20, False: 2.26k] ------------------ 732| 20| TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one"); ------------------ | | 135| 20|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 733| 20| } 734| | // 2) Parse flags and width if we did not do it in previous step. 735| 4.01k| if (!widthSet) { ------------------ | Branch (735:9): [True: 3.54k, False: 479] ------------------ 736| | // Parse flags 737| 4.80k| for (;; ++c) { 738| 4.80k| switch (*c) { 739| 102| case '#': ------------------ | Branch (739:17): [True: 102, False: 4.70k] ------------------ 740| 102| out.setf(std::ios::showpoint | std::ios::showbase); 741| 102| continue; 742| 38| case '0': ------------------ | Branch (742:17): [True: 38, False: 4.76k] ------------------ 743| | // overridden by left alignment ('-' flag) 744| 38| if (!(out.flags() & std::ios::left)) { ------------------ | Branch (744:25): [True: 20, False: 18] ------------------ 745| | // Use internal padding so that numeric values are 746| | // formatted correctly, eg -00010 rather than 000-10 747| 20| out.fill('0'); 748| 20| out.setf(std::ios::internal, std::ios::adjustfield); 749| 20| } 750| 38| continue; 751| 249| case '-': ------------------ | Branch (751:17): [True: 249, False: 4.55k] ------------------ 752| 249| out.fill(' '); 753| 249| out.setf(std::ios::left, std::ios::adjustfield); 754| 249| continue; 755| 692| case ' ': ------------------ | Branch (755:17): [True: 692, False: 4.11k] ------------------ 756| | // overridden by show positive sign, '+' flag. 757| 692| if (!(out.flags() & std::ios::showpos)) ------------------ | Branch (757:25): [True: 604, False: 88] ------------------ 758| 604| spacePadPositive = true; 759| 692| continue; 760| 182| case '+': ------------------ | Branch (760:17): [True: 182, False: 4.62k] ------------------ 761| 182| out.setf(std::ios::showpos); 762| 182| spacePadPositive = false; 763| 182| widthExtra = 1; 764| 182| continue; 765| 3.54k| default: ------------------ | Branch (765:17): [True: 3.54k, False: 1.26k] ------------------ 766| 3.54k| break; 767| 4.80k| } 768| 3.54k| break; 769| 4.80k| } 770| | // Parse width 771| 3.54k| int width = 0; 772| 3.54k| widthSet = parseWidthOrPrecision(width, c, positionalMode, 773| 3.54k| args, argIndex, numArgs); 774| 3.54k| if (widthSet) { ------------------ | Branch (774:13): [True: 238, False: 3.30k] ------------------ 775| 238| if (width < 0) { ------------------ | Branch (775:17): [True: 10, False: 228] ------------------ 776| | // negative widths correspond to '-' flag set 777| 10| out.fill(' '); 778| 10| out.setf(std::ios::left, std::ios::adjustfield); 779| 10| width = -width; 780| 10| } 781| 238| out.width(width); 782| 238| } 783| 3.54k| } 784| | // 3) Parse precision 785| 4.01k| if (*c == '.') { ------------------ | Branch (785:9): [True: 1.34k, False: 2.67k] ------------------ 786| 1.34k| ++c; 787| 1.34k| int precision = 0; 788| 1.34k| parseWidthOrPrecision(precision, c, positionalMode, 789| 1.34k| args, argIndex, numArgs); 790| | // Presence of `.` indicates precision set, unless the inferred value 791| | // was negative in which case the default is used. 792| 1.34k| precisionSet = precision >= 0; 793| 1.34k| if (precisionSet) ------------------ | Branch (793:13): [True: 1.33k, False: 9] ------------------ 794| 1.33k| out.precision(precision); 795| 1.34k| } 796| | // 4) Ignore any C99 length modifier 797| 4.70k| while (*c == 'l' || *c == 'h' || *c == 'L' || ------------------ | Branch (797:12): [True: 95, False: 4.60k] | Branch (797:25): [True: 200, False: 4.40k] | Branch (797:38): [True: 72, False: 4.33k] ------------------ 798| 4.33k| *c == 'j' || *c == 'z' || *c == 't') { ------------------ | Branch (798:12): [True: 76, False: 4.26k] | Branch (798:25): [True: 75, False: 4.18k] | Branch (798:38): [True: 180, False: 4.00k] ------------------ 799| 685| ++c; 800| 685| } 801| | // 5) We're up to the conversion specifier character. 802| | // Set stream flags based on conversion specifier (thanks to the 803| | // boost::format class for forging the way here). 804| 4.01k| bool intConversion = false; 805| 4.01k| switch (*c) { 806| 428| case 'u': case 'd': case 'i': ------------------ | Branch (806:9): [True: 130, False: 3.88k] | Branch (806:19): [True: 174, False: 3.84k] | Branch (806:29): [True: 124, False: 3.89k] ------------------ 807| 428| out.setf(std::ios::dec, std::ios::basefield); 808| 428| intConversion = true; 809| 428| break; 810| 128| case 'o': ------------------ | Branch (810:9): [True: 128, False: 3.89k] ------------------ 811| 128| out.setf(std::ios::oct, std::ios::basefield); 812| 128| intConversion = true; 813| 128| break; 814| 127| case 'X': ------------------ | Branch (814:9): [True: 127, False: 3.89k] ------------------ 815| 127| out.setf(std::ios::uppercase); 816| 127| [[fallthrough]]; 817| 312| case 'x': case 'p': ------------------ | Branch (817:9): [True: 124, False: 3.89k] | Branch (817:19): [True: 61, False: 3.95k] ------------------ 818| 312| out.setf(std::ios::hex, std::ios::basefield); 819| 312| intConversion = true; 820| 312| break; 821| 44| case 'E': ------------------ | Branch (821:9): [True: 44, False: 3.97k] ------------------ 822| 44| out.setf(std::ios::uppercase); 823| 44| [[fallthrough]]; 824| 97| case 'e': ------------------ | Branch (824:9): [True: 53, False: 3.96k] ------------------ 825| 97| out.setf(std::ios::scientific, std::ios::floatfield); 826| 97| out.setf(std::ios::dec, std::ios::basefield); 827| 97| break; 828| 72| case 'F': ------------------ | Branch (828:9): [True: 72, False: 3.94k] ------------------ 829| 72| out.setf(std::ios::uppercase); 830| 72| [[fallthrough]]; 831| 104| case 'f': ------------------ | Branch (831:9): [True: 32, False: 3.98k] ------------------ 832| 104| out.setf(std::ios::fixed, std::ios::floatfield); 833| 104| break; 834| 42| case 'A': ------------------ | Branch (834:9): [True: 42, False: 3.97k] ------------------ 835| 42| out.setf(std::ios::uppercase); 836| 42| [[fallthrough]]; 837| 103| case 'a': ------------------ | Branch (837:9): [True: 61, False: 3.95k] ------------------ 838| |# ifdef _MSC_VER 839| | // Workaround https://developercommunity.visualstudio.com/content/problem/520472/hexfloat-stream-output-does-not-ignore-precision-a.html 840| | // by always setting maximum precision on MSVC to avoid precision 841| | // loss for doubles. 842| | out.precision(13); 843| |# endif 844| 103| out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield); 845| 103| break; 846| 34| case 'G': ------------------ | Branch (846:9): [True: 34, False: 3.98k] ------------------ 847| 34| out.setf(std::ios::uppercase); 848| 34| [[fallthrough]]; 849| 63| case 'g': ------------------ | Branch (849:9): [True: 29, False: 3.99k] ------------------ 850| 63| out.setf(std::ios::dec, std::ios::basefield); 851| | // As in boost::format, let stream decide float format. 852| 63| out.flags(out.flags() & ~std::ios::floatfield); 853| 63| break; 854| 44| case 'c': ------------------ | Branch (854:9): [True: 44, False: 3.97k] ------------------ 855| | // Handled as special case inside formatValue() 856| 44| break; 857| 1.35k| case 's': ------------------ | Branch (857:9): [True: 1.35k, False: 2.66k] ------------------ 858| 1.35k| if (precisionSet) ------------------ | Branch (858:17): [True: 1.16k, False: 192] ------------------ 859| 1.16k| ntrunc = static_cast(out.precision()); 860| | // Make %s print Booleans as "true" and "false" 861| 1.35k| out.setf(std::ios::boolalpha); 862| 1.35k| break; 863| 5| case 'n': ------------------ | Branch (863:9): [True: 5, False: 4.01k] ------------------ 864| | // Not supported - will cause problems! 865| 5| TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported"); ------------------ | | 135| 5|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 866| 0| break; 867| 352| case '\0': ------------------ | Branch (867:9): [True: 352, False: 3.66k] ------------------ 868| 352| TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly " ------------------ | | 135| 352|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 869| 34| "terminated by end of string"); 870| 0| return c; 871| 1.01k| default: ------------------ | Branch (871:9): [True: 1.01k, False: 3.00k] ------------------ 872| 1.01k| break; 873| 4.01k| } 874| 3.64k| if (intConversion && precisionSet && !widthSet) { ------------------ | Branch (874:9): [True: 868, False: 2.78k] | Branch (874:26): [True: 36, False: 832] | Branch (874:42): [True: 26, False: 10] ------------------ 875| | // "precision" for integers gives the minimum number of digits (to be 876| | // padded with zeros on the left). This isn't really supported by the 877| | // iostreams, but we can approximately simulate it with the width if 878| | // the width isn't otherwise used. 879| 26| out.width(out.precision() + widthExtra); 880| 26| out.setf(std::ios::internal, std::ios::adjustfield); 881| 26| out.fill('0'); 882| 26| } 883| 3.64k| return c+1; 884| 4.01k|} _ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi: 891| 3.57k|{ 892| | // Saved stream state 893| 3.57k| std::streamsize origWidth = out.width(); 894| 3.57k| std::streamsize origPrecision = out.precision(); 895| 3.57k| std::ios::fmtflags origFlags = out.flags(); 896| 3.57k| char origFill = out.fill(); 897| | 898| | // "Positional mode" means all format specs should be of the form "%n$..." 899| | // with `n` an integer. We detect this in `streamStateFromFormat`. 900| 3.57k| bool positionalMode = false; 901| 3.57k| int argIndex = 0; 902| 7.62k| while (true) { ------------------ | Branch (902:12): [True: 7.15k, Folded] ------------------ 903| 7.15k| fmt = printFormatStringLiteral(out, fmt); 904| 7.15k| if (*fmt == '\0') { ------------------ | Branch (904:13): [True: 3.02k, False: 4.12k] ------------------ 905| 3.02k| if (!positionalMode && argIndex < numArgs) { ------------------ | Branch (905:17): [True: 2.49k, False: 529] | Branch (905:36): [True: 805, False: 1.69k] ------------------ 906| 805| TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string"); ------------------ | | 135| 805|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 907| 805| } 908| 2.22k| break; 909| 3.02k| } 910| 4.12k| bool spacePadPositive = false; 911| 4.12k| int ntrunc = -1; 912| 4.12k| const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt, 913| 4.12k| args, argIndex, numArgs); 914| | // NB: argIndex may be incremented by reading variable width/precision 915| | // in `streamStateFromFormat`, so do the bounds check here. 916| 4.12k| if (argIndex >= numArgs) { ------------------ | Branch (916:13): [True: 69, False: 4.05k] ------------------ 917| 69| TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string"); ------------------ | | 135| 69|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 918| 0| return; 919| 69| } 920| 4.05k| const FormatArg& arg = args[argIndex]; 921| | // Format the arg into the stream. 922| 4.05k| if (!spacePadPositive) { ------------------ | Branch (922:13): [True: 3.06k, False: 991] ------------------ 923| 3.06k| arg.format(out, fmt, fmtEnd, ntrunc); 924| 3.06k| } 925| 991| else { 926| | // The following is a special case with no direct correspondence 927| | // between stream formatting and the printf() behaviour. Simulate 928| | // it crudely by formatting into a temporary string stream and 929| | // munging the resulting string. 930| 991| std::ostringstream tmpStream; 931| 991| tmpStream.copyfmt(out); 932| 991| tmpStream.setf(std::ios::showpos); 933| 991| arg.format(tmpStream, fmt, fmtEnd, ntrunc); 934| 991| std::string result = tmpStream.str(); // allocates... yuck. 935| 12.4M| for (size_t i = 0, iend = result.size(); i < iend; ++i) { ------------------ | Branch (935:54): [True: 12.4M, False: 991] ------------------ 936| 12.4M| if (result[i] == '+') ------------------ | Branch (936:21): [True: 610, False: 12.4M] ------------------ 937| 610| result[i] = ' '; 938| 12.4M| } 939| 991| out << result; 940| 991| } 941| 4.05k| if (!positionalMode) ------------------ | Branch (941:13): [True: 2.34k, False: 1.71k] ------------------ 942| 2.34k| ++argIndex; 943| 4.05k| fmt = fmtEnd; 944| 4.05k| } 945| | 946| | // Restore stream state 947| 2.69k| out.width(origWidth); 948| 2.69k| out.precision(origPrecision); 949| 2.69k| out.flags(origFlags); 950| 2.69k| out.fill(origFill); 951| 2.69k|} _ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE: 1070| 3.57k|{ 1071| 3.57k| detail::formatImpl(out, fmt, list.m_args, list.m_N); 1072| 3.57k|} _ZN10tinyformat6detail11FormatListNILi1EEC2IJbEEEDpRKT_: 990| 262| : FormatList(&m_formatterStore[0], N), 991| 262| m_formatterStore { FormatArg(args)... } 992| 262| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IbEERKT_: 534| 262| : m_value(static_cast(&value)), 535| 262| m_formatImpl(&formatImpl), 536| 262| m_toIntImpl(&toIntImpl) 537| 262| { } _ZN10tinyformat6detail9FormatArg10formatImplImEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 86| { 559| 86| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 86| } _ZN10tinyformat11formatValueImEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 86|{ 352| 86|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 86| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 86| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 86|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 86| const bool canConvertToChar = detail::is_convertible::value; 364| 86| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 86| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 86, Folded] | Branch (365:29): [True: 0, False: 86] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 86| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 86] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 86| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 47, False: 39] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 47| detail::formatTruncated(out, value, ntrunc); 376| 47| } 377| 39| else 378| 39| out << value; 379| 86|} _ZN10tinyformat6detail15formatTruncatedImEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 47|{ 310| 47| std::ostringstream tmp; 311| 47| tmp << value; 312| 47| std::string result = tmp.str(); 313| 47| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 47|} _ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 106| { 559| 106| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 106| } _ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 106|{ 352| 106|#ifndef TINYFORMAT_ALLOW_WCHAR_STRINGS 353| | // Since we don't support printing of wchar_t using "%ls", make it fail at 354| | // compile time in preference to printing as a void* at runtime. 355| 106| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 106| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 106|#endif 358| | // The mess here is to support the %c and %p conversions: if these 359| | // conversions are active we try to convert the type to a char or const 360| | // void* respectively and format that instead of the value itself. For the 361| | // %p conversion it's important to avoid dereferencing the pointer, which 362| | // could otherwise lead to a crash when printing a dangling (const char*). 363| 106| const bool canConvertToChar = detail::is_convertible::value; 364| 106| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 106| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 106, Folded] | Branch (365:29): [True: 0, False: 106] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 106| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 106] | Branch (367:37): [True: 0, False: 0] ------------------ 368| 0| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 106| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 53, False: 53] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 53| detail::formatTruncated(out, value, ntrunc); 376| 53| } 377| 53| else 378| 53| out << value; 379| 106|} _ZN10tinyformat6detail15formatTruncatedIiEEvRNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEERKT_i: 309| 53|{ 310| 53| std::ostringstream tmp; 311| 53| tmp << value; 312| 53| std::string result = tmp.str(); 313| 53| out.write(result.c_str(), (std::min)(ntrunc, static_cast(result.size()))); 314| 53|} _ZN10tinyformat6formatIJmEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 101|{ 1089| 101| std::ostringstream oss; 1090| 101| format(oss, fmt, args...); 1091| 101| return oss.str(); 1092| 101|} _ZN10tinyformat6formatIJmEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 101|{ 1081| 101| vformat(out, fmt, makeFormatList(args...)); 1082| 101|} _ZN10tinyformat14makeFormatListIJmEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 101|{ 1045| 101| return detail::FormatListN(args...); 1046| 101|} _ZN10tinyformat6detail9FormatArgC2IiEERKT_: 534| 99| : m_value(static_cast(&value)), 535| 99| m_formatImpl(&formatImpl), 536| 99| m_toIntImpl(&toIntImpl) 537| 99| { } _ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_: 534| 781| : m_value(static_cast(&value)), 535| 781| m_formatImpl(&formatImpl), 536| 781| m_toIntImpl(&toIntImpl) 537| 781| { } _ZN10tinyformat6detail9FormatArgC2IjEERKT_: 534| 109| : m_value(static_cast(&value)), 535| 109| m_formatImpl(&formatImpl), 536| 109| m_toIntImpl(&toIntImpl) 537| 109| { } _ZN10tinyformat6detail11FormatListNILi1EEC2IJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEDpRKT_: 990| 781| : FormatList(&m_formatterStore[0], N), 991| 781| m_formatterStore { FormatArg(args)... } 992| 781| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail11FormatListNILi1EEC2IJjEEEDpRKT_: 990| 109| : FormatList(&m_formatterStore[0], N), 991| 109| m_formatterStore { FormatArg(args)... } 992| 109| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IlEERKT_: 534| 94| : m_value(static_cast(&value)), 535| 94| m_formatImpl(&formatImpl), 536| 94| m_toIntImpl(&toIntImpl) 537| 94| { } _ZN10tinyformat6detail11FormatListNILi1EEC2IJmEEEDpRKT_: 990| 101| : FormatList(&m_formatterStore[0], N), 991| 101| m_formatterStore { FormatArg(args)... } 992| 101| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2ImEERKT_: 534| 101| : m_value(static_cast(&value)), 535| 101| m_formatImpl(&formatImpl), 536| 101| m_toIntImpl(&toIntImpl) 537| 101| { } _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.87k|{ 91| 1.87k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 1.87k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 1.87k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 1.87k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 1.87k| } 96| 1.87k| return std::forward(val); 97| 1.87k|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 1.87k|{ 91| 1.87k| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 1.87k, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 1.87k| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 1.87k] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 1.87k| } 96| 1.87k| return std::forward(val); 97| 1.87k|} _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|} _Z7IsDigitc: 151| 15.6k|{ 152| 15.6k| return c >= '0' && c <= '9'; ------------------ | Branch (152:12): [True: 6.88k, False: 8.76k] | Branch (152:24): [True: 3.75k, False: 3.13k] ------------------ 153| 15.6k|} _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.87k|{ 55| 1.87k| Assert(mock_time_in >= 0s); ------------------ | | 116| 1.87k|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 1.87k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 1.87k|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 1.87k|{ 85| 1.87k| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 1.87k|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;