_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| } _ZN18FuzzedDataProvider29ConsumeRemainingBytesAsStringEv: 188| 285|inline std::string FuzzedDataProvider::ConsumeRemainingBytesAsString() { 189| 285| return ConsumeBytesAsString(remaining_bytes_); 190| 285|} _ZN18FuzzedDataProvider15ConsumeIntegralIiEET_v: 195| 285|template T FuzzedDataProvider::ConsumeIntegral() { 196| 285| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 285| std::numeric_limits::max()); 198| 285|} _ZN18FuzzedDataProviderC2EPKhm: 37| 285| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider20ConsumeBytesAsStringEm: 137| 285|inline std::string FuzzedDataProvider::ConsumeBytesAsString(size_t num_bytes) { 138| 285| static_assert(sizeof(std::string::value_type) == sizeof(uint8_t), 139| 285| "ConsumeBytesAsString cannot convert the data to a string."); 140| | 141| 285| num_bytes = std::min(num_bytes, remaining_bytes_); 142| 285| std::string result( 143| 285| reinterpret_cast(data_ptr_), num_bytes); 144| 285| Advance(num_bytes); 145| 285| return result; 146| 285|} _ZN18FuzzedDataProvider7AdvanceEm: 343| 285|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 344| 285| if (num_bytes > remaining_bytes_) ------------------ | Branch (344:7): [True: 0, False: 285] ------------------ 345| 0| abort(); 346| | 347| 285| data_ptr_ += num_bytes; 348| 285| remaining_bytes_ -= num_bytes; 349| 285|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIiEET_S1_S1_: 205| 285|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 285| static_assert(std::is_integral_v, "An integral type is required."); 207| 285| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 285| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 285] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 285| uint64_t range = static_cast(max) - static_cast(min); 214| 285| uint64_t result = 0; 215| 285| size_t offset = 0; 216| | 217| 1.32k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 1.09k, False: 230] | Branch (217:43): [True: 1.09k, False: 0] ------------------ 218| 1.09k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 1.04k, False: 55] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 1.04k| --remaining_bytes_; 226| 1.04k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 1.04k| offset += CHAR_BIT; 228| 1.04k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 285| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 285, False: 0] ------------------ 232| 285| result = result % (range + 1); 233| | 234| 285| return static_cast(static_cast(min) + result); 235| 285|} LLVMFuzzerTestOneInput: 213| 285|{ 214| 285| test_one_input({data, size}); 215| 285| return 0; 216| 285|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 84| 285|{ 85| 285| CheckGlobals check{}; 86| 285| (*Assert(g_test_one_input))(buffer); ------------------ | | 116| 285|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 87| 285|} _Z25parse_iso8601_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 15| 285|{ 16| 285| FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); 17| | 18| 285| const int64_t random_time = fuzzed_data_provider.ConsumeIntegral(); 19| 285| const std::string random_string = fuzzed_data_provider.ConsumeRemainingBytesAsString(); 20| | 21| 285| const std::string iso8601_datetime = FormatISO8601DateTime(random_time); 22| 285| (void)FormatISO8601Date(random_time); 23| 285| const int64_t parsed_time_1{ParseISO8601DateTime(iso8601_datetime).value()}; 24| 285| assert(parsed_time_1 == random_time); ------------------ | Branch (24:5): [True: 285, False: 0] ------------------ 25| | 26| 285| (void)ParseISO8601DateTime(random_string); 27| 285|} _ZN12CheckGlobalsC2Ev: 59| 285|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 60| 287|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 285| { 18| 285| g_used_g_prng = false; 19| 285| g_seeded_g_prng_zero = false; 20| 285| g_used_system_time = false; 21| 285| SetMockTime(0s); 22| 285| MockableSteadyClock::ClearMockTime(); 23| 285| } _ZN16CheckGlobalsImplD2Ev: 25| 287| { 26| 287| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (26:13): [True: 0, False: 287] | 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| 287| if (g_used_system_time) { ------------------ | Branch (42:13): [True: 0, False: 287] ------------------ 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| 287| } __gcov_reset: 13| 2|extern "C" __attribute__((weak)) void __gcov_reset(void) {} _ZN10tinyformat6formatIJijjllxEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 285|{ 1089| 285| std::ostringstream oss; 1090| 285| format(oss, fmt, args...); 1091| 285| return oss.str(); 1092| 285|} _ZN10tinyformat6formatIJijjllxEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 285|{ 1081| 285| vformat(out, fmt, makeFormatList(args...)); 1082| 285|} _ZN10tinyformat14makeFormatListIJijjllxEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 285|{ 1045| 285| return detail::FormatListN(args...); 1046| 285|} _ZN10tinyformat6detail11FormatListNILi6EEC2IJijjllxEEEDpRKT_: 990| 285| : FormatList(&m_formatterStore[0], N), 991| 285| m_formatterStore { FormatArg(args)... } 992| 285| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6formatIJijjEEENSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 285|{ 1089| 285| std::ostringstream oss; 1090| 285| format(oss, fmt, args...); 1091| 285| return oss.str(); 1092| 285|} _ZN10tinyformat6formatIJijjEEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 285|{ 1081| 285| vformat(out, fmt, makeFormatList(args...)); 1082| 285|} _ZN10tinyformat14makeFormatListIJijjEEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 285|{ 1045| 285| return detail::FormatListN(args...); 1046| 285|} _ZN10tinyformat6detail11FormatListNILi3EEC2IJijjEEEDpRKT_: 990| 285| : FormatList(&m_formatterStore[0], N), 991| 285| m_formatterStore { FormatArg(args)... } 992| 285| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArg10formatImplIjEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 1.14k| { 559| 1.14k| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 1.14k| } _ZN10tinyformat11formatValueIjEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 1.14k|{ 352| 1.14k|#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.14k| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 1.14k| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 1.14k|#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.14k| const bool canConvertToChar = detail::is_convertible::value; 364| 1.14k| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 1.14k| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 1.14k, Folded] | Branch (365:29): [True: 0, False: 1.14k] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 1.14k| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 1.14k] | 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.14k| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 1.14k] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 0| detail::formatTruncated(out, value, ntrunc); 376| 0| } 377| 1.14k| else 378| 1.14k| out << value; 379| 1.14k|} _ZN10tinyformat6detail9FormatArg10formatImplIlEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 570| { 559| 570| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 570| } _ZN10tinyformat11formatValueIlEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 570|{ 352| 570|#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| 570| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 570| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 570|#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| 570| const bool canConvertToChar = detail::is_convertible::value; 364| 570| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 570| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 570, Folded] | Branch (365:29): [True: 0, False: 570] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 570| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 570] | 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| 570| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 570] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 0| detail::formatTruncated(out, value, ntrunc); 376| 0| } 377| 570| else 378| 570| out << value; 379| 570|} _ZN10tinyformat17FormatStringCheckILj6EEcvPKcEv: 197| 285| operator const char*() { return fmt; } _ZN10tinyformat6detail9FormatArgC2IxEERKT_: 534| 285| : m_value(static_cast(&value)), 535| 285| m_formatImpl(&formatImpl), 536| 285| m_toIntImpl(&toIntImpl) 537| 285| { } _ZN10tinyformat6detail9FormatArg10formatImplIxEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 285| { 559| 285| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 285| } _ZN10tinyformat11formatValueIxEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 285|{ 352| 285|#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| 285| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 285| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 285|#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| 285| const bool canConvertToChar = detail::is_convertible::value; 364| 285| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 285| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 285, Folded] | Branch (365:29): [True: 0, False: 285] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 285| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 285] | 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| 285| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 285] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 0| detail::formatTruncated(out, value, ntrunc); 376| 0| } 377| 285| else 378| 285| out << value; 379| 285|} _ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i: 541| 2.56k| { 542| 2.56k| TINYFORMAT_ASSERT(m_value); ------------------ | | 153| 2.56k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (542:13): [True: 2.56k, False: 0] ------------------ 543| 2.56k| TINYFORMAT_ASSERT(m_formatImpl); ------------------ | | 153| 2.56k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (543:13): [True: 2.56k, False: 0] ------------------ 544| 2.56k| m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); 545| 2.56k| } _ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi: 966| 570| : m_args(args), m_N(N) { } _ZN10tinyformat6detail18parseIntAndAdvanceERPKc: 578| 2.56k|{ 579| 2.56k| int i = 0; 580| 7.69k| for (;*c >= '0' && *c <= '9'; ++c) ------------------ | Branch (580:11): [True: 7.69k, False: 0] | Branch (580:24): [True: 5.13k, False: 2.56k] ------------------ 581| 5.13k| i = 10*i + (*c - '0'); 582| 2.56k| return i; 583| 2.56k|} _ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc: 629| 3.13k|{ 630| 3.13k| const char* c = fmt; 631| 5.41k| for (;; ++c) { 632| 5.41k| if (*c == '\0') { ------------------ | Branch (632:13): [True: 570, False: 4.84k] ------------------ 633| 570| out.write(fmt, c - fmt); 634| 570| return c; 635| 570| } 636| 4.84k| else if (*c == '%') { ------------------ | Branch (636:18): [True: 2.56k, False: 2.28k] ------------------ 637| 2.56k| out.write(fmt, c - fmt); 638| 2.56k| if (*(c+1) != '%') ------------------ | Branch (638:17): [True: 2.56k, False: 0] ------------------ 639| 2.56k| return c; 640| | // for "%%", tack trailing % onto next literal section. 641| 0| fmt = ++c; 642| 0| } 643| 5.41k| } 644| 3.13k|} _ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i: 685| 2.56k|{ 686| 2.56k| TINYFORMAT_ASSERT(*fmtStart == '%'); ------------------ | | 153| 2.56k|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ | Branch (686:5): [True: 2.56k, False: 0] ------------------ 687| | // Reset stream state to defaults. 688| 2.56k| out.width(0); 689| 2.56k| out.precision(6); 690| 2.56k| out.fill(' '); 691| | // Reset most flags; ignore irrelevant unitbuf & skipws. 692| 2.56k| out.unsetf(std::ios::adjustfield | std::ios::basefield | 693| 2.56k| std::ios::floatfield | std::ios::showbase | std::ios::boolalpha | 694| 2.56k| std::ios::showpoint | std::ios::showpos | std::ios::uppercase); 695| 2.56k| bool precisionSet = false; 696| 2.56k| bool widthSet = false; 697| 2.56k| int widthExtra = 0; 698| 2.56k| 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| 2.56k| if (*c >= '0' && *c <= '9') { ------------------ | Branch (702:9): [True: 2.56k, False: 0] | Branch (702:22): [True: 2.56k, False: 0] ------------------ 703| 2.56k| const char tmpc = *c; 704| 2.56k| int value = parseIntAndAdvance(c); 705| 2.56k| if (*c == '$') { ------------------ | Branch (705:13): [True: 0, False: 2.56k] ------------------ 706| | // value is an argument index 707| 0| if (value > 0 && value <= numArgs) ------------------ | Branch (707:17): [True: 0, False: 0] | Branch (707:30): [True: 0, False: 0] ------------------ 708| 0| argIndex = value - 1; 709| 0| else 710| 0| TINYFORMAT_ERROR("tinyformat: Positional argument out of range"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 711| 0| ++c; 712| 0| positionalMode = true; 713| 0| } 714| 2.56k| else if (positionalMode) { ------------------ | Branch (714:18): [True: 0, False: 2.56k] ------------------ 715| 0| TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 716| 0| } 717| 2.56k| else { 718| 2.56k| if (tmpc == '0') { ------------------ | Branch (718:17): [True: 2.56k, False: 0] ------------------ 719| | // Use internal padding so that numeric values are 720| | // formatted correctly, eg -00010 rather than 000-10 721| 2.56k| out.fill('0'); 722| 2.56k| out.setf(std::ios::internal, std::ios::adjustfield); 723| 2.56k| } 724| 2.56k| if (value != 0) { ------------------ | Branch (724:17): [True: 2.56k, False: 0] ------------------ 725| | // Nonzero value means that we parsed width. 726| 2.56k| widthSet = true; 727| 2.56k| out.width(value); 728| 2.56k| } 729| 2.56k| } 730| 2.56k| } 731| 0| else if (positionalMode) { ------------------ | Branch (731:14): [True: 0, False: 0] ------------------ 732| 0| TINYFORMAT_ERROR("tinyformat: Non-positional argument used after a positional one"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 733| 0| } 734| | // 2) Parse flags and width if we did not do it in previous step. 735| 2.56k| if (!widthSet) { ------------------ | Branch (735:9): [True: 0, False: 2.56k] ------------------ 736| | // Parse flags 737| 0| for (;; ++c) { 738| 0| switch (*c) { 739| 0| case '#': ------------------ | Branch (739:17): [True: 0, False: 0] ------------------ 740| 0| out.setf(std::ios::showpoint | std::ios::showbase); 741| 0| continue; 742| 0| case '0': ------------------ | Branch (742:17): [True: 0, False: 0] ------------------ 743| | // overridden by left alignment ('-' flag) 744| 0| if (!(out.flags() & std::ios::left)) { ------------------ | Branch (744:25): [True: 0, False: 0] ------------------ 745| | // Use internal padding so that numeric values are 746| | // formatted correctly, eg -00010 rather than 000-10 747| 0| out.fill('0'); 748| 0| out.setf(std::ios::internal, std::ios::adjustfield); 749| 0| } 750| 0| continue; 751| 0| case '-': ------------------ | Branch (751:17): [True: 0, False: 0] ------------------ 752| 0| out.fill(' '); 753| 0| out.setf(std::ios::left, std::ios::adjustfield); 754| 0| continue; 755| 0| case ' ': ------------------ | Branch (755:17): [True: 0, False: 0] ------------------ 756| | // overridden by show positive sign, '+' flag. 757| 0| if (!(out.flags() & std::ios::showpos)) ------------------ | Branch (757:25): [True: 0, False: 0] ------------------ 758| 0| spacePadPositive = true; 759| 0| continue; 760| 0| case '+': ------------------ | Branch (760:17): [True: 0, False: 0] ------------------ 761| 0| out.setf(std::ios::showpos); 762| 0| spacePadPositive = false; 763| 0| widthExtra = 1; 764| 0| continue; 765| 0| default: ------------------ | Branch (765:17): [True: 0, False: 0] ------------------ 766| 0| break; 767| 0| } 768| 0| break; 769| 0| } 770| | // Parse width 771| 0| int width = 0; 772| 0| widthSet = parseWidthOrPrecision(width, c, positionalMode, 773| 0| args, argIndex, numArgs); 774| 0| if (widthSet) { ------------------ | Branch (774:13): [True: 0, False: 0] ------------------ 775| 0| if (width < 0) { ------------------ | Branch (775:17): [True: 0, False: 0] ------------------ 776| | // negative widths correspond to '-' flag set 777| 0| out.fill(' '); 778| 0| out.setf(std::ios::left, std::ios::adjustfield); 779| 0| width = -width; 780| 0| } 781| 0| out.width(width); 782| 0| } 783| 0| } 784| | // 3) Parse precision 785| 2.56k| if (*c == '.') { ------------------ | Branch (785:9): [True: 0, False: 2.56k] ------------------ 786| 0| ++c; 787| 0| int precision = 0; 788| 0| parseWidthOrPrecision(precision, c, positionalMode, 789| 0| args, argIndex, numArgs); 790| | // Presence of `.` indicates precision set, unless the inferred value 791| | // was negative in which case the default is used. 792| 0| precisionSet = precision >= 0; 793| 0| if (precisionSet) ------------------ | Branch (793:13): [True: 0, False: 0] ------------------ 794| 0| out.precision(precision); 795| 0| } 796| | // 4) Ignore any C99 length modifier 797| 2.56k| while (*c == 'l' || *c == 'h' || *c == 'L' || ------------------ | Branch (797:12): [True: 0, False: 2.56k] | Branch (797:25): [True: 0, False: 2.56k] | Branch (797:38): [True: 0, False: 2.56k] ------------------ 798| 2.56k| *c == 'j' || *c == 'z' || *c == 't') { ------------------ | Branch (798:12): [True: 0, False: 2.56k] | Branch (798:25): [True: 0, False: 2.56k] | Branch (798:38): [True: 0, False: 2.56k] ------------------ 799| 0| ++c; 800| 0| } 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| 2.56k| bool intConversion = false; 805| 2.56k| switch (*c) { 806| 2.56k| case 'u': case 'd': case 'i': ------------------ | Branch (806:9): [True: 1.14k, False: 1.42k] | Branch (806:19): [True: 0, False: 2.56k] | Branch (806:29): [True: 1.42k, False: 1.14k] ------------------ 807| 2.56k| out.setf(std::ios::dec, std::ios::basefield); 808| 2.56k| intConversion = true; 809| 2.56k| break; 810| 0| case 'o': ------------------ | Branch (810:9): [True: 0, False: 2.56k] ------------------ 811| 0| out.setf(std::ios::oct, std::ios::basefield); 812| 0| intConversion = true; 813| 0| break; 814| 0| case 'X': ------------------ | Branch (814:9): [True: 0, False: 2.56k] ------------------ 815| 0| out.setf(std::ios::uppercase); 816| 0| [[fallthrough]]; 817| 0| case 'x': case 'p': ------------------ | Branch (817:9): [True: 0, False: 2.56k] | Branch (817:19): [True: 0, False: 2.56k] ------------------ 818| 0| out.setf(std::ios::hex, std::ios::basefield); 819| 0| intConversion = true; 820| 0| break; 821| 0| case 'E': ------------------ | Branch (821:9): [True: 0, False: 2.56k] ------------------ 822| 0| out.setf(std::ios::uppercase); 823| 0| [[fallthrough]]; 824| 0| case 'e': ------------------ | Branch (824:9): [True: 0, False: 2.56k] ------------------ 825| 0| out.setf(std::ios::scientific, std::ios::floatfield); 826| 0| out.setf(std::ios::dec, std::ios::basefield); 827| 0| break; 828| 0| case 'F': ------------------ | Branch (828:9): [True: 0, False: 2.56k] ------------------ 829| 0| out.setf(std::ios::uppercase); 830| 0| [[fallthrough]]; 831| 0| case 'f': ------------------ | Branch (831:9): [True: 0, False: 2.56k] ------------------ 832| 0| out.setf(std::ios::fixed, std::ios::floatfield); 833| 0| break; 834| 0| case 'A': ------------------ | Branch (834:9): [True: 0, False: 2.56k] ------------------ 835| 0| out.setf(std::ios::uppercase); 836| 0| [[fallthrough]]; 837| 0| case 'a': ------------------ | Branch (837:9): [True: 0, False: 2.56k] ------------------ 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| 0| out.setf(std::ios::fixed | std::ios::scientific, std::ios::floatfield); 845| 0| break; 846| 0| case 'G': ------------------ | Branch (846:9): [True: 0, False: 2.56k] ------------------ 847| 0| out.setf(std::ios::uppercase); 848| 0| [[fallthrough]]; 849| 0| case 'g': ------------------ | Branch (849:9): [True: 0, False: 2.56k] ------------------ 850| 0| out.setf(std::ios::dec, std::ios::basefield); 851| | // As in boost::format, let stream decide float format. 852| 0| out.flags(out.flags() & ~std::ios::floatfield); 853| 0| break; 854| 0| case 'c': ------------------ | Branch (854:9): [True: 0, False: 2.56k] ------------------ 855| | // Handled as special case inside formatValue() 856| 0| break; 857| 0| case 's': ------------------ | Branch (857:9): [True: 0, False: 2.56k] ------------------ 858| 0| if (precisionSet) ------------------ | Branch (858:17): [True: 0, False: 0] ------------------ 859| 0| ntrunc = static_cast(out.precision()); 860| | // Make %s print Booleans as "true" and "false" 861| 0| out.setf(std::ios::boolalpha); 862| 0| break; 863| 0| case 'n': ------------------ | Branch (863:9): [True: 0, False: 2.56k] ------------------ 864| | // Not supported - will cause problems! 865| 0| TINYFORMAT_ERROR("tinyformat: %n conversion spec not supported"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 866| 0| break; 867| 0| case '\0': ------------------ | Branch (867:9): [True: 0, False: 2.56k] ------------------ 868| 0| TINYFORMAT_ERROR("tinyformat: Conversion spec incorrectly " ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 869| 0| "terminated by end of string"); 870| 0| return c; 871| 0| default: ------------------ | Branch (871:9): [True: 0, False: 2.56k] ------------------ 872| 0| break; 873| 2.56k| } 874| 2.56k| if (intConversion && precisionSet && !widthSet) { ------------------ | Branch (874:9): [True: 2.56k, False: 0] | Branch (874:26): [True: 0, False: 2.56k] | Branch (874:42): [True: 0, False: 0] ------------------ 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| 0| out.width(out.precision() + widthExtra); 880| 0| out.setf(std::ios::internal, std::ios::adjustfield); 881| 0| out.fill('0'); 882| 0| } 883| 2.56k| return c+1; 884| 2.56k|} _ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi: 891| 570|{ 892| | // Saved stream state 893| 570| std::streamsize origWidth = out.width(); 894| 570| std::streamsize origPrecision = out.precision(); 895| 570| std::ios::fmtflags origFlags = out.flags(); 896| 570| 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| 570| bool positionalMode = false; 901| 570| int argIndex = 0; 902| 3.13k| while (true) { ------------------ | Branch (902:12): [True: 3.13k, Folded] ------------------ 903| 3.13k| fmt = printFormatStringLiteral(out, fmt); 904| 3.13k| if (*fmt == '\0') { ------------------ | Branch (904:13): [True: 570, False: 2.56k] ------------------ 905| 570| if (!positionalMode && argIndex < numArgs) { ------------------ | Branch (905:17): [True: 570, False: 0] | Branch (905:36): [True: 0, False: 570] ------------------ 906| 0| TINYFORMAT_ERROR("tinyformat: Not enough conversion specifiers in format string"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 907| 0| } 908| 570| break; 909| 570| } 910| 2.56k| bool spacePadPositive = false; 911| 2.56k| int ntrunc = -1; 912| 2.56k| const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt, 913| 2.56k| args, argIndex, numArgs); 914| | // NB: argIndex may be incremented by reading variable width/precision 915| | // in `streamStateFromFormat`, so do the bounds check here. 916| 2.56k| if (argIndex >= numArgs) { ------------------ | Branch (916:13): [True: 0, False: 2.56k] ------------------ 917| 0| TINYFORMAT_ERROR("tinyformat: Too many conversion specifiers in format string"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 918| 0| return; 919| 0| } 920| 2.56k| const FormatArg& arg = args[argIndex]; 921| | // Format the arg into the stream. 922| 2.56k| if (!spacePadPositive) { ------------------ | Branch (922:13): [True: 2.56k, False: 0] ------------------ 923| 2.56k| arg.format(out, fmt, fmtEnd, ntrunc); 924| 2.56k| } 925| 0| 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| 0| std::ostringstream tmpStream; 931| 0| tmpStream.copyfmt(out); 932| 0| tmpStream.setf(std::ios::showpos); 933| 0| arg.format(tmpStream, fmt, fmtEnd, ntrunc); 934| 0| std::string result = tmpStream.str(); // allocates... yuck. 935| 0| for (size_t i = 0, iend = result.size(); i < iend; ++i) { ------------------ | Branch (935:54): [True: 0, False: 0] ------------------ 936| 0| if (result[i] == '+') ------------------ | Branch (936:21): [True: 0, False: 0] ------------------ 937| 0| result[i] = ' '; 938| 0| } 939| 0| out << result; 940| 0| } 941| 2.56k| if (!positionalMode) ------------------ | Branch (941:13): [True: 2.56k, False: 0] ------------------ 942| 2.56k| ++argIndex; 943| 2.56k| fmt = fmtEnd; 944| 2.56k| } 945| | 946| | // Restore stream state 947| 570| out.width(origWidth); 948| 570| out.precision(origPrecision); 949| 570| out.flags(origFlags); 950| 570| out.fill(origFill); 951| 570|} _ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE: 1070| 570|{ 1071| 570| detail::formatImpl(out, fmt, list.m_args, list.m_N); 1072| 570|} _ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 570| { 559| 570| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 570| } _ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 570|{ 352| 570|#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| 570| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 570| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 570|#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| 570| const bool canConvertToChar = detail::is_convertible::value; 364| 570| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 570| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [True: 570, Folded] | Branch (365:29): [True: 0, False: 570] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 570| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded, False: 570] | 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| 570| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 570] ------------------ 373| | // Take care not to overread C strings in truncating conversions like 374| | // "%.4s" where at most 4 characters may be read. 375| 0| detail::formatTruncated(out, value, ntrunc); 376| 0| } 377| 570| else 378| 570| out << value; 379| 570|} _ZN10tinyformat17FormatStringCheckILj3EEcvPKcEv: 197| 285| operator const char*() { return fmt; } _ZN10tinyformat6detail9FormatArgC2IiEERKT_: 534| 570| : m_value(static_cast(&value)), 535| 570| m_formatImpl(&formatImpl), 536| 570| m_toIntImpl(&toIntImpl) 537| 570| { } _ZN10tinyformat6detail9FormatArgC2IjEERKT_: 534| 1.14k| : m_value(static_cast(&value)), 535| 1.14k| m_formatImpl(&formatImpl), 536| 1.14k| m_toIntImpl(&toIntImpl) 537| 1.14k| { } _ZN10tinyformat6detail9FormatArgC2IlEERKT_: 534| 570| : m_value(static_cast(&value)), 535| 570| m_formatImpl(&formatImpl), 536| 570| m_toIntImpl(&toIntImpl) 537| 570| { } _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| 285|{ 91| 285| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 285, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 285| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 285] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 285| } 96| 285| return std::forward(val); 97| 285|} _Z22inline_assertion_checkILb1EbEOT0_S1_RKNSt3__115source_locationENS2_17basic_string_viewIcNS2_11char_traitsIcEEEE: 90| 285|{ 91| 285| if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { ------------------ | Branch (91:9): [True: 285, Folded] | Branch (91:22): [Folded, False: 0] | Branch (91:54): [True: 0, Folded] ------------------ 92| 285| if (!val) { ------------------ | Branch (92:13): [True: 0, False: 285] ------------------ 93| 0| assertion_fail(loc, assertion); 94| 0| } 95| 285| } 96| 285| return std::forward(val); 97| 285|} _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|} _Z10ToIntegralIhENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEEm: 181| 1.73k|{ 182| 1.73k| static_assert(std::is_integral_v); 183| 1.73k| T result; 184| 1.73k| const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result, base); 185| 1.73k| if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) { ------------------ | Branch (185:9): [True: 142, False: 1.58k] | Branch (185:57): [True: 0, False: 1.58k] ------------------ 186| 142| return std::nullopt; 187| 142| } 188| 1.58k| return result; 189| 1.73k|} _Z10ToIntegralItENSt3__18optionalIT_EENS0_17basic_string_viewIcNS0_11char_traitsIcEEEEm: 181| 346|{ 182| 346| static_assert(std::is_integral_v); 183| 346| T result; 184| 346| const auto [first_nonmatching, error_condition] = std::from_chars(str.data(), str.data() + str.size(), result, base); 185| 346| if (first_nonmatching != str.data() + str.size() || error_condition != std::errc{}) { ------------------ | Branch (185:9): [True: 33, False: 313] | Branch (185:57): [True: 0, False: 313] ------------------ 186| 33| return std::nullopt; 187| 33| } 188| 313| return result; 189| 346|} _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| 285|{ 55| 285| Assert(mock_time_in >= 0s); ------------------ | | 116| 285|#define Assert(val) inline_assertion_check(val, std::source_location::current(), #val) ------------------ 56| 285| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 57| 285|} _ZN19MockableSteadyClock13ClearMockTimeEv: 84| 285|{ 85| 285| g_mock_steady_time.store(0ms, std::memory_order_relaxed); 86| 285|} _Z21FormatISO8601DateTimel: 91| 285|{ 92| 285| const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}}; 93| 285| const auto days{std::chrono::floor(secs)}; 94| 285| const std::chrono::year_month_day ymd{days}; 95| 285| const std::chrono::hh_mm_ss hms{secs - days}; 96| 285| return strprintf("%04i-%02u-%02uT%02i:%02i:%02iZ", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()}, hms.hours().count(), hms.minutes().count(), hms.seconds().count()); ------------------ | | 1172| 285|#define strprintf tfm::format ------------------ 97| 285|} _Z17FormatISO8601Datel: 100| 285|{ 101| 285| const std::chrono::sys_seconds secs{std::chrono::seconds{nTime}}; 102| 285| const auto days{std::chrono::floor(secs)}; 103| 285| const std::chrono::year_month_day ymd{days}; 104| 285| return strprintf("%04i-%02u-%02u", signed{ymd.year()}, unsigned{ymd.month()}, unsigned{ymd.day()}); ------------------ | | 1172| 285|#define strprintf tfm::format ------------------ 105| 285|} _Z20ParseISO8601DateTimeNSt3__117basic_string_viewIcNS_11char_traitsIcEEEE: 108| 570|{ 109| 570| constexpr auto FMT_SIZE{std::string_view{"2000-01-01T01:01:01Z"}.size()}; 110| 570| if (str.size() != FMT_SIZE || str[4] != '-' || str[7] != '-' || str[10] != 'T' || str[13] != ':' || str[16] != ':' || str[19] != 'Z') { ------------------ | Branch (110:9): [True: 164, False: 406] | Branch (110:35): [True: 10, False: 396] | Branch (110:52): [True: 11, False: 385] | Branch (110:69): [True: 10, False: 375] | Branch (110:87): [True: 9, False: 366] | Branch (110:105): [True: 9, False: 357] | Branch (110:123): [True: 11, False: 346] ------------------ 111| 224| return {}; 112| 224| } 113| 346| const auto year{ToIntegral(str.substr(0, 4))}; 114| 346| const auto month{ToIntegral(str.substr(5, 2))}; 115| 346| const auto day{ToIntegral(str.substr(8, 2))}; 116| 346| const auto hour{ToIntegral(str.substr(11, 2))}; 117| 346| const auto min{ToIntegral(str.substr(14, 2))}; 118| 346| const auto sec{ToIntegral(str.substr(17, 2))}; 119| 346| if (!year || !month || !day || !hour || !min || !sec) { ------------------ | Branch (119:9): [True: 33, False: 313] | Branch (119:18): [True: 1, False: 312] | Branch (119:28): [True: 2, False: 310] | Branch (119:36): [True: 1, False: 309] | Branch (119:45): [True: 1, False: 308] | Branch (119:53): [True: 1, False: 307] ------------------ 120| 39| return {}; 121| 39| } 122| 307| const std::chrono::year_month_day ymd{std::chrono::year{*year}, std::chrono::month{*month}, std::chrono::day{*day}}; 123| 307| if (!ymd.ok()) { ------------------ | Branch (123:9): [True: 12, False: 295] ------------------ 124| 12| return {}; 125| 12| } 126| 295| const auto time{std::chrono::hours{*hour} + std::chrono::minutes{*min} + std::chrono::seconds{*sec}}; 127| 295| const auto tp{std::chrono::sys_days{ymd} + time}; 128| 295| return int64_t{TicksSinceEpoch(tp)}; 129| 307|} _Z5TicksINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEES5_EDaT0_: 83| 295|{ 84| 295| return std::chrono::duration_cast(d).count(); 85| 295|} _Z15TicksSinceEpochINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEENS1_10time_pointINS1_12system_clockES5_EEEDaT0_: 94| 295|{ 95| 295| return Ticks(t.time_since_epoch()); 96| 295|} _ZN19WalletInitInterfaceD2Ev: 25| 2| virtual ~WalletInitInterface() = default;