_ZN13arith_uint256C2Ev: 248| 677| arith_uint256() = default; _ZN9base_uintILj256EEC2Ev: 34| 677| { 35| 6.09k| for (int i = 0; i < WIDTH; i++) ------------------ | Branch (35:25): [True: 5.41k, False: 677] ------------------ 36| 5.41k| pn[i] = 0; 37| 677| } _ZN9base_uintILj256EEC2ERKS0_: 40| 376| { 41| 3.38k| for (int i = 0; i < WIDTH; i++) ------------------ | Branch (41:25): [True: 3.00k, False: 376] ------------------ 42| 3.00k| pn[i] = b.pn[i]; 43| 376| } _ZNK11CBlockIndex8ToStringEv: 16| 188|{ 17| 188| return strprintf("CBlockIndex(pprev=%p, nHeight=%d, merkle=%s, hashBlock=%s)", ------------------ | | 1172| 188|#define strprintf tfm::format ------------------ 18| 188| pprev, nHeight, hashMerkleRoot.ToString(), GetBlockHash().ToString()); 19| 188|} _ZN11CBlockIndex9BuildSkipEv: 126| 188|{ 127| 188| if (pprev) ------------------ | Branch (127:9): [True: 0, False: 188] ------------------ 128| 0| pskip = pprev->GetAncestor(GetSkipHeight(nHeight)); 129| 188|} _ZN11CBlockIndexC2ERK12CBlockHeader: 200| 188| : nVersion{block.nVersion}, 201| 188| hashMerkleRoot{block.hashMerkleRoot}, 202| 188| nTime{block.nTime}, 203| 188| nBits{block.nBits}, 204| 188| nNonce{block.nNonce} 205| 188| { 206| 188| } _ZNK11CBlockIndex11GetBlockPosEv: 209| 188| { 210| 188| AssertLockHeld(::cs_main); ------------------ | | 142| 188|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs) ------------------ 211| 188| FlatFilePos ret; 212| 188| if (nStatus & BLOCK_HAVE_DATA) { ------------------ | Branch (212:13): [True: 26, False: 162] ------------------ 213| 26| ret.nFile = nFile; 214| 26| ret.nPos = nDataPos; 215| 26| } 216| 188| return ret; 217| 188| } _ZNK11CBlockIndex10GetUndoPosEv: 220| 188| { 221| 188| AssertLockHeld(::cs_main); ------------------ | | 142| 188|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs) ------------------ 222| 188| FlatFilePos ret; 223| 188| if (nStatus & BLOCK_HAVE_UNDO) { ------------------ | Branch (223:13): [True: 38, False: 150] ------------------ 224| 38| ret.nFile = nFile; 225| 38| ret.nPos = nUndoPos; 226| 38| } 227| 188| return ret; 228| 188| } _ZNK11CBlockIndex14GetBlockHeaderEv: 231| 188| { 232| 188| CBlockHeader block; 233| 188| block.nVersion = nVersion; 234| 188| if (pprev) ------------------ | Branch (234:13): [True: 0, False: 188] ------------------ 235| 0| block.hashPrevBlock = pprev->GetBlockHash(); 236| 188| block.hashMerkleRoot = hashMerkleRoot; 237| 188| block.nTime = nTime; 238| 188| block.nBits = nBits; 239| 188| block.nNonce = nNonce; 240| 188| return block; 241| 188| } _ZNK11CBlockIndex12GetBlockHashEv: 244| 376| { 245| 376| assert(phashBlock != nullptr); 246| 376| return *phashBlock; 247| 376| } _ZNK11CBlockIndex15HaveNumChainTxsEv: 259| 188| bool HaveNumChainTxs() const { return m_chain_tx_count != 0; } _ZNK11CBlockIndex12GetBlockTimeEv: 267| 376| { 268| 376| return (int64_t)nTime; 269| 376| } _ZNK11CBlockIndex15GetBlockTimeMaxEv: 272| 188| { 273| 188| return (int64_t)nTimeMax; 274| 188| } _ZNK11CBlockIndex17GetMedianTimePastEv: 279| 188| { 280| 188| int64_t pmedian[nMedianTimeSpan]; 281| 188| int64_t* pbegin = &pmedian[nMedianTimeSpan]; 282| 188| int64_t* pend = &pmedian[nMedianTimeSpan]; 283| | 284| 188| const CBlockIndex* pindex = this; 285| 376| for (int i = 0; i < nMedianTimeSpan && pindex; i++, pindex = pindex->pprev) ------------------ | Branch (285:25): [True: 376, False: 0] | Branch (285:48): [True: 188, False: 188] ------------------ 286| 188| *(--pbegin) = pindex->GetBlockTime(); 287| | 288| 188| std::sort(pbegin, pend); 289| 188| return pbegin[(pend - pbegin) / 2]; 290| 188| } _ZNK11CBlockIndex7IsValidE11BlockStatus: 297| 188| { 298| 188| AssertLockHeld(::cs_main); ------------------ | | 142| 188|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs) ------------------ 299| 188| assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed. 300| 188| if (nStatus & BLOCK_FAILED_MASK) ------------------ | Branch (300:13): [True: 75, False: 113] ------------------ 301| 75| return false; 302| 113| return ((nStatus & BLOCK_VALID_MASK) >= nUpTo); 303| 188| } _ZN11CBlockIndex13RaiseValidityE11BlockStatus: 308| 4.51k| { 309| 4.51k| AssertLockHeld(::cs_main); ------------------ | | 142| 4.51k|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs) ------------------ 310| 4.51k| assert(!(nUpTo & ~BLOCK_VALID_MASK)); // Only validity flags allowed. 311| 4.51k| if (nStatus & BLOCK_FAILED_MASK) return false; ------------------ | Branch (311:13): [True: 1.60k, False: 2.90k] ------------------ 312| | 313| 2.90k| if ((nStatus & BLOCK_VALID_MASK) < nUpTo) { ------------------ | Branch (313:13): [True: 26, False: 2.88k] ------------------ 314| 26| nStatus = (nStatus & ~BLOCK_VALID_MASK) | nUpTo; 315| 26| return true; 316| 26| } 317| 2.88k| return false; 318| 2.90k| } _ZN15CDiskBlockIndexC2Ev: 368| 489| { 369| 489| hashPrev = uint256(); 370| 489| } _ZNK15CDiskBlockIndex18ConstructBlockHashEv: 400| 188| { 401| 188| CBlockHeader block; 402| 188| block.nVersion = nVersion; 403| 188| block.hashPrevBlock = hashPrev; 404| 188| block.hashMerkleRoot = hashMerkleRoot; 405| 188| block.nTime = nTime; 406| 188| block.nBits = nBits; 407| 188| block.nNonce = nNonce; 408| 188| return block.GetHash(); 409| 188| } _ZN11CBlockIndexC2ERKS_: 340| 376| CBlockIndex(const CBlockIndex&) = default; _ZN11CBlockIndexC2Ev: 327| 489| CBlockIndex() = default; _ZN15CDiskBlockIndex16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_: 378| 489| { 379| 489| LOCK(::cs_main); ------------------ | | 257| 489|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 489|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 489|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 489|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 380| 489| int _nVersion = DUMMY_VERSION; 381| 489| READWRITE(VARINT_MODE(_nVersion, VarIntMode::NONNEGATIVE_SIGNED)); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 382| | 383| 489| READWRITE(VARINT_MODE(obj.nHeight, VarIntMode::NONNEGATIVE_SIGNED)); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 384| 489| READWRITE(VARINT(obj.nStatus)); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 385| 489| READWRITE(VARINT(obj.nTx)); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 386| 489| if (obj.nStatus & (BLOCK_HAVE_DATA | BLOCK_HAVE_UNDO)) READWRITE(VARINT_MODE(obj.nFile, VarIntMode::NONNEGATIVE_SIGNED)); ------------------ | | 156| 95|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ | Branch (386:13): [True: 95, False: 394] ------------------ 387| 489| if (obj.nStatus & BLOCK_HAVE_DATA) READWRITE(VARINT(obj.nDataPos)); ------------------ | | 156| 68|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ | Branch (387:13): [True: 68, False: 421] ------------------ 388| 489| if (obj.nStatus & BLOCK_HAVE_UNDO) READWRITE(VARINT(obj.nUndoPos)); ------------------ | | 156| 82|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ | Branch (388:13): [True: 82, False: 407] ------------------ 389| | 390| | // block header 391| 489| READWRITE(obj.nVersion); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 392| 489| READWRITE(obj.hashPrev); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 393| 489| READWRITE(obj.hashMerkleRoot); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 394| 489| READWRITE(obj.nTime); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 395| 489| READWRITE(obj.nBits); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 396| 489| READWRITE(obj.nNonce); ------------------ | | 156| 489|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ 397| 489| } _Z17internal_bswap_32j: 54| 12.0k|{ 55| 12.0k|#ifdef bitcoin_builtin_bswap32 56| 12.0k| return bitcoin_builtin_bswap32(x); ------------------ | | 24| 12.0k|# define bitcoin_builtin_bswap32(x) __builtin_bswap32(x) ------------------ 57| |#else 58| | return (((x & 0xff000000U) >> 24) | ((x & 0x00ff0000U) >> 8) | 59| | ((x & 0x0000ff00U) << 8) | ((x & 0x000000ffU) << 24)); 60| |#endif 61| 12.0k|} _Z17internal_bswap_64m: 64| 376|{ 65| 376|#ifdef bitcoin_builtin_bswap64 66| 376| return bitcoin_builtin_bswap64(x); ------------------ | | 27| 376|# define bitcoin_builtin_bswap64(x) __builtin_bswap64(x) ------------------ 67| |#else 68| | return (((x & 0xff00000000000000ull) >> 56) 69| | | ((x & 0x00ff000000000000ull) >> 40) 70| | | ((x & 0x0000ff0000000000ull) >> 24) 71| | | ((x & 0x000000ff00000000ull) >> 8) 72| | | ((x & 0x00000000ff000000ull) << 8) 73| | | ((x & 0x0000000000ff0000ull) << 24) 74| | | ((x & 0x000000000000ff00ull) << 40) 75| | | ((x & 0x00000000000000ffull) << 56)); 76| |#endif 77| 376|} _Z16htobe32_internalj: 34| 3.00k|{ 35| 3.00k| if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits); 36| | else return host_32bits; 37| 3.00k|} _Z16htole32_internalj: 39| 752|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 752| else return host_32bits; 42| 752|} _Z16be32toh_internalj: 44| 9.02k|{ 45| 9.02k| if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(big_endian_32bits); 46| | else return big_endian_32bits; 47| 9.02k|} _Z16le32toh_internalj: 49| 814|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 814| else return little_endian_32bits; 52| 814|} _Z16htobe64_internalm: 54| 376|{ 55| 376| if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits); 56| | else return host_64bits; 57| 376|} _Z9WriteBE32ITk8ByteTypehEvPT_j: 96| 3.00k|{ 97| 3.00k| uint32_t v = htobe32_internal(x); 98| 3.00k| memcpy(ptr, &v, 4); 99| 3.00k|} _Z8ReadBE32ITk8ByteTypehEjPKT_: 73| 9.02k|{ 74| 9.02k| uint32_t x; 75| 9.02k| memcpy(&x, ptr, 4); 76| 9.02k| return be32toh_internal(x); 77| 9.02k|} _Z9WriteBE64ITk8ByteTypehEvPT_m: 103| 376|{ 104| 376| uint64_t v = htobe64_internal(x); 105| 376| memcpy(ptr, &v, 8); 106| 376|} _Z6HexStr4SpanIKhE: 30| 376|{ 31| 376| std::string rv(s.size() * 2, '\0'); 32| 376| static constexpr auto byte_to_hex = CreateByteToHexMap(); 33| 376| static_assert(sizeof(byte_to_hex) == 512); 34| | 35| 376| char* it = rv.data(); 36| 12.0k| for (uint8_t v : s) { ------------------ | Branch (36:20): [True: 12.0k, False: 376] ------------------ 37| 12.0k| std::memcpy(it, byte_to_hex[v].data(), 2); 38| 12.0k| it += 2; 39| 12.0k| } 40| | 41| 376| assert(it == rv.data() + rv.size()); 42| 376| return rv; 43| 376|} _ZN7CSHA256C2Ev: 697| 188|{ 698| 188| sha256::Initialize(s); 699| 188|} _ZN7CSHA2565WriteEPKhm: 702| 2.06k|{ 703| 2.06k| const unsigned char* end = data + len; 704| 2.06k| size_t bufsize = bytes % 64; 705| 2.06k| if (bufsize && bufsize + len >= 64) { ------------------ | Branch (705:9): [True: 1.69k, False: 376] | Branch (705:20): [True: 564, False: 1.12k] ------------------ 706| | // Fill the buffer, and process it. 707| 564| memcpy(buf + bufsize, data, 64 - bufsize); 708| 564| bytes += 64 - bufsize; 709| 564| data += 64 - bufsize; 710| 564| Transform(s, buf, 1); 711| 564| bufsize = 0; 712| 564| } 713| 2.06k| if (end - data >= 64) { ------------------ | Branch (713:9): [True: 0, False: 2.06k] ------------------ 714| 0| size_t blocks = (end - data) / 64; 715| 0| Transform(s, data, blocks); 716| 0| data += 64 * blocks; 717| 0| bytes += 64 * blocks; 718| 0| } 719| 2.06k| if (end > data) { ------------------ | Branch (719:9): [True: 1.69k, False: 376] ------------------ 720| | // Fill the buffer with what remains. 721| 1.69k| memcpy(buf + bufsize, data, end - data); 722| 1.69k| bytes += end - data; 723| 1.69k| } 724| 2.06k| return *this; 725| 2.06k|} _ZN7CSHA2568FinalizeEPh: 728| 376|{ 729| 376| static const unsigned char pad[64] = {0x80}; 730| 376| unsigned char sizedesc[8]; 731| 376| WriteBE64(sizedesc, bytes << 3); 732| 376| Write(pad, 1 + ((119 - (bytes % 64)) % 64)); 733| 376| Write(sizedesc, 8); 734| 376| WriteBE32(hash, s[0]); 735| 376| WriteBE32(hash + 4, s[1]); 736| 376| WriteBE32(hash + 8, s[2]); 737| 376| WriteBE32(hash + 12, s[3]); 738| 376| WriteBE32(hash + 16, s[4]); 739| 376| WriteBE32(hash + 20, s[5]); 740| 376| WriteBE32(hash + 24, s[6]); 741| 376| WriteBE32(hash + 28, s[7]); 742| 376|} _ZN7CSHA2565ResetEv: 745| 188|{ 746| 188| bytes = 0; 747| 188| sha256::Initialize(s); 748| 188| return *this; 749| 188|} sha256.cpp:_ZN12_GLOBAL__N_16sha2569TransformEPjPKhm: 102| 564|{ 103| 1.12k| while (blocks--) { ------------------ | Branch (103:12): [True: 564, False: 564] ------------------ 104| 564| uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7]; 105| 564| uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15; 106| | 107| 564| Round(a, b, c, d, e, f, g, h, 0x428a2f98 + (w0 = ReadBE32(chunk + 0))); 108| 564| Round(h, a, b, c, d, e, f, g, 0x71374491 + (w1 = ReadBE32(chunk + 4))); 109| 564| Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf + (w2 = ReadBE32(chunk + 8))); 110| 564| Round(f, g, h, a, b, c, d, e, 0xe9b5dba5 + (w3 = ReadBE32(chunk + 12))); 111| 564| Round(e, f, g, h, a, b, c, d, 0x3956c25b + (w4 = ReadBE32(chunk + 16))); 112| 564| Round(d, e, f, g, h, a, b, c, 0x59f111f1 + (w5 = ReadBE32(chunk + 20))); 113| 564| Round(c, d, e, f, g, h, a, b, 0x923f82a4 + (w6 = ReadBE32(chunk + 24))); 114| 564| Round(b, c, d, e, f, g, h, a, 0xab1c5ed5 + (w7 = ReadBE32(chunk + 28))); 115| 564| Round(a, b, c, d, e, f, g, h, 0xd807aa98 + (w8 = ReadBE32(chunk + 32))); 116| 564| Round(h, a, b, c, d, e, f, g, 0x12835b01 + (w9 = ReadBE32(chunk + 36))); 117| 564| Round(g, h, a, b, c, d, e, f, 0x243185be + (w10 = ReadBE32(chunk + 40))); 118| 564| Round(f, g, h, a, b, c, d, e, 0x550c7dc3 + (w11 = ReadBE32(chunk + 44))); 119| 564| Round(e, f, g, h, a, b, c, d, 0x72be5d74 + (w12 = ReadBE32(chunk + 48))); 120| 564| Round(d, e, f, g, h, a, b, c, 0x80deb1fe + (w13 = ReadBE32(chunk + 52))); 121| 564| Round(c, d, e, f, g, h, a, b, 0x9bdc06a7 + (w14 = ReadBE32(chunk + 56))); 122| 564| Round(b, c, d, e, f, g, h, a, 0xc19bf174 + (w15 = ReadBE32(chunk + 60))); 123| | 124| 564| Round(a, b, c, d, e, f, g, h, 0xe49b69c1 + (w0 += sigma1(w14) + w9 + sigma0(w1))); 125| 564| Round(h, a, b, c, d, e, f, g, 0xefbe4786 + (w1 += sigma1(w15) + w10 + sigma0(w2))); 126| 564| Round(g, h, a, b, c, d, e, f, 0x0fc19dc6 + (w2 += sigma1(w0) + w11 + sigma0(w3))); 127| 564| Round(f, g, h, a, b, c, d, e, 0x240ca1cc + (w3 += sigma1(w1) + w12 + sigma0(w4))); 128| 564| Round(e, f, g, h, a, b, c, d, 0x2de92c6f + (w4 += sigma1(w2) + w13 + sigma0(w5))); 129| 564| Round(d, e, f, g, h, a, b, c, 0x4a7484aa + (w5 += sigma1(w3) + w14 + sigma0(w6))); 130| 564| Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc + (w6 += sigma1(w4) + w15 + sigma0(w7))); 131| 564| Round(b, c, d, e, f, g, h, a, 0x76f988da + (w7 += sigma1(w5) + w0 + sigma0(w8))); 132| 564| Round(a, b, c, d, e, f, g, h, 0x983e5152 + (w8 += sigma1(w6) + w1 + sigma0(w9))); 133| 564| Round(h, a, b, c, d, e, f, g, 0xa831c66d + (w9 += sigma1(w7) + w2 + sigma0(w10))); 134| 564| Round(g, h, a, b, c, d, e, f, 0xb00327c8 + (w10 += sigma1(w8) + w3 + sigma0(w11))); 135| 564| Round(f, g, h, a, b, c, d, e, 0xbf597fc7 + (w11 += sigma1(w9) + w4 + sigma0(w12))); 136| 564| Round(e, f, g, h, a, b, c, d, 0xc6e00bf3 + (w12 += sigma1(w10) + w5 + sigma0(w13))); 137| 564| Round(d, e, f, g, h, a, b, c, 0xd5a79147 + (w13 += sigma1(w11) + w6 + sigma0(w14))); 138| 564| Round(c, d, e, f, g, h, a, b, 0x06ca6351 + (w14 += sigma1(w12) + w7 + sigma0(w15))); 139| 564| Round(b, c, d, e, f, g, h, a, 0x14292967 + (w15 += sigma1(w13) + w8 + sigma0(w0))); 140| | 141| 564| Round(a, b, c, d, e, f, g, h, 0x27b70a85 + (w0 += sigma1(w14) + w9 + sigma0(w1))); 142| 564| Round(h, a, b, c, d, e, f, g, 0x2e1b2138 + (w1 += sigma1(w15) + w10 + sigma0(w2))); 143| 564| Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc + (w2 += sigma1(w0) + w11 + sigma0(w3))); 144| 564| Round(f, g, h, a, b, c, d, e, 0x53380d13 + (w3 += sigma1(w1) + w12 + sigma0(w4))); 145| 564| Round(e, f, g, h, a, b, c, d, 0x650a7354 + (w4 += sigma1(w2) + w13 + sigma0(w5))); 146| 564| Round(d, e, f, g, h, a, b, c, 0x766a0abb + (w5 += sigma1(w3) + w14 + sigma0(w6))); 147| 564| Round(c, d, e, f, g, h, a, b, 0x81c2c92e + (w6 += sigma1(w4) + w15 + sigma0(w7))); 148| 564| Round(b, c, d, e, f, g, h, a, 0x92722c85 + (w7 += sigma1(w5) + w0 + sigma0(w8))); 149| 564| Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1 + (w8 += sigma1(w6) + w1 + sigma0(w9))); 150| 564| Round(h, a, b, c, d, e, f, g, 0xa81a664b + (w9 += sigma1(w7) + w2 + sigma0(w10))); 151| 564| Round(g, h, a, b, c, d, e, f, 0xc24b8b70 + (w10 += sigma1(w8) + w3 + sigma0(w11))); 152| 564| Round(f, g, h, a, b, c, d, e, 0xc76c51a3 + (w11 += sigma1(w9) + w4 + sigma0(w12))); 153| 564| Round(e, f, g, h, a, b, c, d, 0xd192e819 + (w12 += sigma1(w10) + w5 + sigma0(w13))); 154| 564| Round(d, e, f, g, h, a, b, c, 0xd6990624 + (w13 += sigma1(w11) + w6 + sigma0(w14))); 155| 564| Round(c, d, e, f, g, h, a, b, 0xf40e3585 + (w14 += sigma1(w12) + w7 + sigma0(w15))); 156| 564| Round(b, c, d, e, f, g, h, a, 0x106aa070 + (w15 += sigma1(w13) + w8 + sigma0(w0))); 157| | 158| 564| Round(a, b, c, d, e, f, g, h, 0x19a4c116 + (w0 += sigma1(w14) + w9 + sigma0(w1))); 159| 564| Round(h, a, b, c, d, e, f, g, 0x1e376c08 + (w1 += sigma1(w15) + w10 + sigma0(w2))); 160| 564| Round(g, h, a, b, c, d, e, f, 0x2748774c + (w2 += sigma1(w0) + w11 + sigma0(w3))); 161| 564| Round(f, g, h, a, b, c, d, e, 0x34b0bcb5 + (w3 += sigma1(w1) + w12 + sigma0(w4))); 162| 564| Round(e, f, g, h, a, b, c, d, 0x391c0cb3 + (w4 += sigma1(w2) + w13 + sigma0(w5))); 163| 564| Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a + (w5 += sigma1(w3) + w14 + sigma0(w6))); 164| 564| Round(c, d, e, f, g, h, a, b, 0x5b9cca4f + (w6 += sigma1(w4) + w15 + sigma0(w7))); 165| 564| Round(b, c, d, e, f, g, h, a, 0x682e6ff3 + (w7 += sigma1(w5) + w0 + sigma0(w8))); 166| 564| Round(a, b, c, d, e, f, g, h, 0x748f82ee + (w8 += sigma1(w6) + w1 + sigma0(w9))); 167| 564| Round(h, a, b, c, d, e, f, g, 0x78a5636f + (w9 += sigma1(w7) + w2 + sigma0(w10))); 168| 564| Round(g, h, a, b, c, d, e, f, 0x84c87814 + (w10 += sigma1(w8) + w3 + sigma0(w11))); 169| 564| Round(f, g, h, a, b, c, d, e, 0x8cc70208 + (w11 += sigma1(w9) + w4 + sigma0(w12))); 170| 564| Round(e, f, g, h, a, b, c, d, 0x90befffa + (w12 += sigma1(w10) + w5 + sigma0(w13))); 171| 564| Round(d, e, f, g, h, a, b, c, 0xa4506ceb + (w13 += sigma1(w11) + w6 + sigma0(w14))); 172| 564| Round(c, d, e, f, g, h, a, b, 0xbef9a3f7 + (w14 + sigma1(w12) + w7 + sigma0(w15))); 173| 564| Round(b, c, d, e, f, g, h, a, 0xc67178f2 + (w15 + sigma1(w13) + w8 + sigma0(w0))); 174| | 175| 564| s[0] += a; 176| 564| s[1] += b; 177| 564| s[2] += c; 178| 564| s[3] += d; 179| 564| s[4] += e; 180| 564| s[5] += f; 181| 564| s[6] += g; 182| 564| s[7] += h; 183| 564| chunk += 64; 184| 564| } 185| 564|} sha256.cpp:_ZN12_GLOBAL__N_16sha2565RoundEjjjRjjjjS1_j: 80| 36.0k|{ 81| 36.0k| uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k; 82| 36.0k| uint32_t t2 = Sigma0(a) + Maj(a, b, c); 83| 36.0k| d += t1; 84| 36.0k| h = t1 + t2; 85| 36.0k|} sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma1Ej: 74| 36.0k|uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7); } sha256.cpp:_ZN12_GLOBAL__N_16sha2562ChEjjj: 71| 36.0k|uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); } sha256.cpp:_ZN12_GLOBAL__N_16sha2566Sigma0Ej: 73| 36.0k|uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); } sha256.cpp:_ZN12_GLOBAL__N_16sha2563MajEjjj: 72| 36.0k|uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); } sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma1Ej: 76| 27.0k|uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); } sha256.cpp:_ZN12_GLOBAL__N_16sha2566sigma0Ej: 75| 27.0k|uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); } sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj: 89| 376|{ 90| 376| s[0] = 0x6a09e667ul; 91| 376| s[1] = 0xbb67ae85ul; 92| 376| s[2] = 0x3c6ef372ul; 93| 376| s[3] = 0xa54ff53aul; 94| 376| s[4] = 0x510e527ful; 95| 376| s[5] = 0x9b05688cul; 96| 376| s[6] = 0x1f83d9abul; 97| 376| s[7] = 0x5be0cd19ul; 98| 376|} _ZN11FlatFilePosC2Ev: 21| 376| FlatFilePos() = default; _ZN10HashWriter5writeE4SpanIKSt4byteE: 107| 1.12k| { 108| 1.12k| ctx.Write(UCharCast(src.data()), src.size()); 109| 1.12k| } _ZN10HashWriter7GetHashEv: 115| 188| uint256 GetHash() { 116| 188| uint256 result; 117| 188| ctx.Finalize(result.begin()); 118| 188| ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin()); 119| 188| return result; 120| 188| } _ZN10HashWriterlsI4SpanIKhEEERS_RKT_: 142| 376| { 143| 376| ::Serialize(*this, obj); 144| 376| return *this; 145| 376| } _ZN10HashWriterlsI12CBlockHeaderEERS_RKT_: 142| 188| { 143| 188| ::Serialize(*this, obj); 144| 188| return *this; 145| 188| } _ZNK12CBlockHeader7GetHashEv: 12| 188|{ 13| 188| return (HashWriter{} << *this).GetHash(); 14| 188|} _ZN12CBlockHeaderC2Ev: 33| 376| { 34| 376| SetNull(); 35| 376| } _ZN12CBlockHeader7SetNullEv: 40| 376| { 41| 376| nVersion = 0; 42| 376| hashPrevBlock.SetNull(); 43| 376| hashMerkleRoot.SetNull(); 44| 376| nTime = 0; 45| 376| nBits = 0; 46| 376| nNonce = 0; 47| 376| } _ZN12CBlockHeader16SerializationOpsI10HashWriterKS_15ActionSerializeEEvRT0_RT_T1_: 37| 188| SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); } ------------------ | | 156| 188|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _Z11UnserializeI10DataStreamEvRT_Ri: 276| 256|template inline void Unserialize(Stream& s, int32_t& a ) { a = ser_readdata32(s); } _Z14ser_readdata32I10DataStreamEjRT_: 102| 827|{ 103| 827| uint32_t obj; 104| 827| s.read(AsWritableBytes(Span{&obj, 1})); 105| 827| return le32toh_internal(obj); 106| 827|} _Z11UnserializeI10DataStreamR7uint256Q14UnserializableIT0_T_EEvRS4_OS3_: 762| 445|{ 763| 445| a.Unserialize(is); 764| 445|} _Z11UnserializeI10DataStreamEvRT_Rj: 277| 571|template inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); } _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJRiEEEvRT_DpOT0_: 1033| 256| { 1034| 256| ::UnserializeMany(s, args...); 1035| 256| } _Z15UnserializeManyI10DataStreamJRiEEvRT_DpOT0_: 1001| 256|{ 1002| 256| (::Unserialize(s, args), ...); 1003| 256|} _Z13ser_readdata8I10DataStreamEhRT_: 84| 3.25k|{ 85| 3.25k| uint8_t obj; 86| 3.25k| s.read(AsWritableBytes(Span{&obj, 1})); 87| 3.25k| return obj; 88| 3.25k|} _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJ7WrapperI15VarIntFormatterIL10VarIntMode0EERjEEEEvRT_DpOT0_: 1033| 789| { 1034| 789| ::UnserializeMany(s, args...); 1035| 789| } _Z15UnserializeManyI10DataStreamJR7WrapperI15VarIntFormatterIL10VarIntMode0EERjEEEvRT_DpOT0_: 1001| 789|{ 1002| 789| (::Unserialize(s, args), ...); 1003| 789|} _Z11UnserializeI10DataStreamR7WrapperI15VarIntFormatterIL10VarIntMode0EERjEQ14UnserializableIT0_T_EEvRS9_OS8_: 762| 789|{ 763| 789| a.Unserialize(is); 764| 789|} _ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERjE11UnserializeI10DataStreamEEvRT_: 483| 789| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN15VarIntFormatterIL10VarIntMode0EE5UnserI10DataStreamjEEvRT_RT0_: 514| 789| { 515| 789| v = ReadVarInt::type>(s); 516| 789| } _Z10ReadVarIntI10DataStreamL10VarIntMode0EjET1_RT_: 453| 789|{ 454| 789| CheckVarIntMode(); 455| 789| I n = 0; 456| 1.58k| while(true) { ------------------ | Branch (456:11): [Folded - Ignored] ------------------ 457| 1.58k| unsigned char chData = ser_readdata8(is); 458| 1.58k| if (n > (std::numeric_limits::max() >> 7)) { ------------------ | Branch (458:13): [True: 29, False: 1.55k] ------------------ 459| 29| throw std::ios_base::failure("ReadVarInt(): size too large"); 460| 29| } 461| 1.55k| n = (n << 7) | (chData & 0x7F); 462| 1.55k| if (chData & 0x80) { ------------------ | Branch (462:13): [True: 795, False: 759] ------------------ 463| 795| if (n == std::numeric_limits::max()) { ------------------ | Branch (463:17): [True: 1, False: 794] ------------------ 464| 1| throw std::ios_base::failure("ReadVarInt(): size too large"); 465| 1| } 466| 794| n++; 467| 794| } else { 468| 759| return n; 469| 759| } 470| 1.55k| } 471| 789|} _ZN15CheckVarIntModeIL10VarIntMode0EjEC2Ev: 410| 789| { 411| 789| static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned::value, "Unsigned type required with mode DEFAULT."); 412| 789| static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed::value, "Signed type required with mode NONNEGATIVE_SIGNED."); 413| 789| } _ZN7WrapperI15VarIntFormatterIL10VarIntMode0EERjEC2ES3_: 481| 789| explicit Wrapper(T obj) : m_object(obj) {} _Z11UnserializeI10DataStreamR15CDiskBlockIndexQ14UnserializableIT0_T_EEvRS4_OS3_: 762| 489|{ 763| 489| a.Unserialize(is); 764| 489|} _ZN15CDiskBlockIndex11UnserializeI10DataStreamEEvRT_: 228| 489| { \ 229| 489| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 489| Unser(s, *this); \ 231| 489| } _ZN15CDiskBlockIndex5UnserI10DataStreamEEvRT_RS_: 180| 489| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJ7WrapperI15VarIntFormatterIL10VarIntMode1EERiEEEEvRT_DpOT0_: 1033| 968| { 1034| 968| ::UnserializeMany(s, args...); 1035| 968| } _Z15UnserializeManyI10DataStreamJR7WrapperI15VarIntFormatterIL10VarIntMode1EERiEEEvRT_DpOT0_: 1001| 968|{ 1002| 968| (::Unserialize(s, args), ...); 1003| 968|} _Z11UnserializeI10DataStreamR7WrapperI15VarIntFormatterIL10VarIntMode1EERiEQ14UnserializableIT0_T_EEvRS9_OS8_: 762| 968|{ 763| 968| a.Unserialize(is); 764| 968|} _ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiE11UnserializeI10DataStreamEEvRT_: 483| 968| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN15VarIntFormatterIL10VarIntMode1EE5UnserI10DataStreamiEEvRT_RT0_: 514| 968| { 515| 968| v = ReadVarInt::type>(s); 516| 968| } _Z10ReadVarIntI10DataStreamL10VarIntMode1EiET1_RT_: 453| 968|{ 454| 968| CheckVarIntMode(); 455| 968| I n = 0; 456| 1.67k| while(true) { ------------------ | Branch (456:11): [Folded - Ignored] ------------------ 457| 1.67k| unsigned char chData = ser_readdata8(is); 458| 1.67k| if (n > (std::numeric_limits::max() >> 7)) { ------------------ | Branch (458:13): [True: 25, False: 1.64k] ------------------ 459| 25| throw std::ios_base::failure("ReadVarInt(): size too large"); 460| 25| } 461| 1.64k| n = (n << 7) | (chData & 0x7F); 462| 1.64k| if (chData & 0x80) { ------------------ | Branch (462:13): [True: 705, False: 942] ------------------ 463| 705| if (n == std::numeric_limits::max()) { ------------------ | Branch (463:17): [True: 1, False: 704] ------------------ 464| 1| throw std::ios_base::failure("ReadVarInt(): size too large"); 465| 1| } 466| 704| n++; 467| 942| } else { 468| 942| return n; 469| 942| } 470| 1.64k| } 471| 968|} _ZN15CheckVarIntModeIL10VarIntMode1EiEC2Ev: 410| 968| { 411| 968| static_assert(Mode != VarIntMode::DEFAULT || std::is_unsigned::value, "Unsigned type required with mode DEFAULT."); 412| 968| static_assert(Mode != VarIntMode::NONNEGATIVE_SIGNED || std::is_signed::value, "Signed type required with mode NONNEGATIVE_SIGNED."); 413| 968| } chain.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode1EERiE7WrapperIT_RT0_EOS6_: 497| 968|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VarIntFormatterIL10VarIntMode1EERiEC2ES3_: 481| 968| explicit Wrapper(T obj) : m_object(obj) {} chain.cpp:_ZL5UsingI15VarIntFormatterIL10VarIntMode0EERjE7WrapperIT_RT0_EOS6_: 497| 789|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJR7uint256EEEvRT_DpOT0_: 1033| 445| { 1034| 445| ::UnserializeMany(s, args...); 1035| 445| } _Z15UnserializeManyI10DataStreamJR7uint256EEvRT_DpOT0_: 1001| 445|{ 1002| 445| (::Unserialize(s, args), ...); 1003| 445|} _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJRjEEEvRT_DpOT0_: 1033| 571| { 1034| 571| ::UnserializeMany(s, args...); 1035| 571| } _Z15UnserializeManyI10DataStreamJRjEEvRT_DpOT0_: 1001| 571|{ 1002| 571| (::Unserialize(s, args), ...); 1003| 571|} _Z9SerializeI10HashWriterEvRT_j: 262| 564|template inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); } _Z15ser_writedata32I10HashWriterEvRT_j: 69| 752|{ 70| 752| obj = htole32_internal(obj); 71| 752| s.write(AsBytes(Span{&obj, 1})); 72| 752|} _Z9SerializeI10HashWriter7uint256Q12SerializableIT0_T_EEvRS3_RKS2_: 753| 376|{ 754| 376| a.Serialize(os); 755| 376|} _Z9SerializeI10HashWriterTk9BasicByteKhEvRT_4SpanIT0_E: 268| 376|template void Serialize(Stream& s, Span span) { s.write(AsBytes(span)); } _Z9SerializeI10HashWriterEvRT_i: 261| 188|template inline void Serialize(Stream& s, int32_t a ) { ser_writedata32(s, a); } _Z9SerializeI10HashWriter12CBlockHeaderQ12SerializableIT0_T_EEvRS3_RKS2_: 753| 188|{ 754| 188| a.Serialize(os); 755| 188|} _ZNK12CBlockHeader9SerializeI10HashWriterEEvRT_: 222| 188| { \ 223| 188| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 188| Ser(s, *this); \ 225| 188| } \ _ZN12CBlockHeader3SerI10HashWriterEEvRT_RKS_: 178| 188| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI10HashWriterJi7uint256S2_jjjEEEvRT_DpRKT0_: 1013| 188| { 1014| 188| ::SerializeMany(s, args...); 1015| 188| } _Z13SerializeManyI10HashWriterJi7uint256S1_jjjEEvRT_DpRKT0_: 995| 188|{ 996| 188| (::Serialize(s, args), ...); 997| 188|} _Z9UCharCastPKSt4byte: 287| 1.12k|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast(c); } _ZNK4SpanIKSt4byteE4sizeEv: 187| 1.61k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 2.10k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE4sizeEv: 187| 376| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKhE5beginEv: 175| 376| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanIKhE3endEv: 176| 376| constexpr C* end() const noexcept { return m_data + m_size; } _ZNK4SpanIhE4dataEv: 174| 3.70k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE4dataEv: 174| 865| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE4sizeEv: 187| 13.3k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteE4dataEv: 174| 4.28k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE10size_bytesEv: 188| 865| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E: 259| 865|{ 260| 865| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 865|} _ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE: 172| 489| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m: 119| 1.61k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK4SpanIjE4dataEv: 174| 1.57k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIjE10size_bytesEv: 188| 1.57k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIjE4SpanIKSt4byteES0_IT_E: 259| 752|{ 260| 752| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 752|} _ZNK4SpanIhE10size_bytesEv: 188| 3.70k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 4.52k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E: 264| 3.70k|{ 265| 3.70k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 3.70k|} _ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m: 119| 3.25k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E: 264| 827|{ 265| 827| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 827|} _ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m: 119| 1.57k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE: 172| 376| : m_data(other.data()), m_size(other.size()){} _Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_: 275| 445|{ 276| 445| return AsWritableBytes(Span{std::forward(v)}); 277| 445|} _ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE: 165| 445| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKhEC2ILi32EEERAT__S0_: 151| 376| constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {} _ZN10DataStreamC2E4SpanIKhE: 165| 489| explicit DataStream(Span sp) : DataStream{AsBytes(sp)} {} _ZN10DataStreamC2E4SpanIKSt4byteE: 166| 489| explicit DataStream(Span sp) : vch(sp.data(), sp.data() + sp.size()) {} _ZN10DataStream4readE4SpanISt4byteE: 219| 4.52k| { 220| 4.52k| if (dst.size() == 0) return; ------------------ | Branch (220:13): [True: 0, False: 4.52k] ------------------ 221| | 222| | // Read from the beginning of the buffer 223| 4.52k| auto next_read_pos{CheckedAdd(m_read_pos, dst.size())}; 224| 4.52k| if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { ------------------ | Branch (224:13): [True: 0, False: 4.52k] | Branch (224:43): [True: 245, False: 4.28k] ------------------ 225| 245| throw std::ios_base::failure("DataStream::read(): end of data"); 226| 245| } 227| 4.28k| memcpy(dst.data(), &vch[m_read_pos], dst.size()); 228| 4.28k| if (next_read_pos.value() == vch.size()) { ------------------ | Branch (228:13): [True: 262, False: 4.02k] ------------------ 229| 262| m_read_pos = 0; 230| 262| vch.clear(); 231| 262| return; 232| 262| } 233| 4.02k| m_read_pos = next_read_pos.value(); 234| 4.02k| } _ZN10DataStreamrsIR15CDiskBlockIndexEERS_OT_: 266| 489| { 267| 489| ::Unserialize(*this, obj); 268| 489| return (*this); 269| 489| } _ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m: 30| 465| { 31| 465| if (p != nullptr) ------------------ | Branch (31:13): [True: 465, False: 0] ------------------ 32| 465| memory_cleanse(p, sizeof(T) * n); 33| 465| std::allocator{}.deallocate(p, n); 34| 465| } _ZN25zero_after_free_allocatorISt4byteE8allocateEm: 25| 465| { 26| 465| return std::allocator{}.allocate(n); 27| 465| } _Z14memory_cleansePvm: 15| 465|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 465| 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| 465| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 465|#endif 35| 465|} _Z13LeaveCriticalv: 76| 5.19k|inline void LeaveCritical() {} _Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_: 253| 9.70k|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; } _Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b: 75| 5.19k|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i: 157| 5.19k| { 158| 5.19k| EnterCritical(pszName, pszFile, nLine, Base::mutex()); 159| |#ifdef DEBUG_LOCKCONTENTION 160| | if (Base::try_lock()) return; 161| | LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", pszName, pszFile, nLine), BCLog::LOCK); 162| |#endif 163| 5.19k| Base::lock(); 164| 5.19k| } _Z22AssertLockHeldInternalI14AnnotatedMixinINSt3__115recursive_mutexEEEvPKcS5_iPT_: 79| 5.07k|inline void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) EXCLUSIVE_LOCKS_REQUIRED(cs) {} _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib: 177| 5.19k| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 178| 5.19k| { 179| 5.19k| if (fTry) ------------------ | Branch (179:13): [True: 0, False: 5.19k] ------------------ 180| 0| TryEnter(pszName, pszFile, nLine); 181| 5.19k| else 182| 5.19k| Enter(pszName, pszFile, nLine); 183| 5.19k| } _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev: 197| 5.19k| { 198| 5.19k| if (Base::owns_lock()) ------------------ | Branch (198:13): [True: 5.19k, False: 0] ------------------ 199| 5.19k| LeaveCritical(); 200| 5.19k| } chain.cpp:_ZZ17chain_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 301| 4.51k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ | | 257| 4.51k|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 4.51k|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 4.51k|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 4.51k|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZN18FuzzedDataProviderC2EPKhm: 37| 489| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 29.0k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 29.0k| static_assert(std::is_integral::value, "An integral type is required."); 207| 29.0k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 29.0k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 29.0k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 29.0k| uint64_t range = static_cast(max) - static_cast(min); 214| 29.0k| uint64_t result = 0; 215| 29.0k| size_t offset = 0; 216| | 217| 58.1k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 58.1k, False: 0] | Branch (217:43): [True: 29.0k, False: 29.0k] ------------------ 218| 58.1k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 29.0k, False: 33] ------------------ 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| 29.0k| --remaining_bytes_; 226| 29.0k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 29.0k| offset += CHAR_BIT; 228| 29.0k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 29.0k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 29.0k, False: 0] ------------------ 232| 29.0k| result = result % (range + 1); 233| | 234| 29.0k| return static_cast(static_cast(min) + result); 235| 29.0k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 29.2k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 29.2k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 29.2k| std::numeric_limits::max()); 198| 29.2k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 29.2k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 29.2k| static_assert(std::is_integral::value, "An integral type is required."); 207| 29.2k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 29.2k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 29.2k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 29.2k| uint64_t range = static_cast(max) - static_cast(min); 214| 29.2k| uint64_t result = 0; 215| 29.2k| size_t offset = 0; 216| | 217| 58.3k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 29.2k, False: 29.1k] | Branch (217:43): [True: 29.2k, False: 0] ------------------ 218| 58.3k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 29.1k, False: 153] ------------------ 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| 29.1k| --remaining_bytes_; 226| 29.1k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 29.1k| offset += CHAR_BIT; 228| 29.1k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 29.2k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 29.2k, False: 0] ------------------ 232| 29.2k| result = result % (range + 1); 233| | 234| 29.2k| return static_cast(static_cast(min) + result); 235| 29.2k|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm: 153| 489|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| 489| std::string result; 161| | 162| | // Reserve the anticipated capacity to prevent several reallocations. 163| 489| result.reserve(std::min(max_length, remaining_bytes_)); 164| 27.4M| for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) { ------------------ | Branch (164:22): [True: 27.4M, False: 297] | Branch (164:40): [True: 27.4M, False: 35] ------------------ 165| 27.4M| char next = ConvertUnsignedToSigned(data_ptr_[0]); 166| 27.4M| Advance(1); 167| 27.4M| if (next == '\\' && remaining_bytes_ != 0) { ------------------ | Branch (167:9): [True: 973, False: 27.4M] | Branch (167:25): [True: 969, False: 4] ------------------ 168| 969| next = ConvertUnsignedToSigned(data_ptr_[0]); 169| 969| Advance(1); 170| 969| if (next != '\\') ------------------ | Branch (170:11): [True: 157, False: 812] ------------------ 171| 157| break; 172| 969| } 173| 27.4M| result += next; 174| 27.4M| } 175| | 176| 489| result.shrink_to_fit(); 177| 489| return result; 178| 489|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv: 181| 489|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() { 182| 489| return ConsumeRandomLengthString(remaining_bytes_); 183| 489|} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 29.2k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 29.2k| return 1 & ConsumeIntegral(); 291| 29.2k|} _ZN18FuzzedDataProvider7AdvanceEm: 344| 27.4M|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 345| 27.4M| if (num_bytes > remaining_bytes_) ------------------ | Branch (345:7): [True: 0, False: 27.4M] ------------------ 346| 0| abort(); 347| | 348| 27.4M| data_ptr_ += num_bytes; 349| 27.4M| remaining_bytes_ -= num_bytes; 350| 27.4M|} _ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_: 379| 27.4M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) { 380| 27.4M| static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types."); 381| 27.4M| static_assert(!std::numeric_limits::is_signed, 382| 27.4M| "Source type must be unsigned."); 383| | 384| | // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream. 385| 27.4M| if (std::numeric_limits::is_modulo) ------------------ | Branch (385:7): [Folded - Ignored] ------------------ 386| 0| return static_cast(value); 387| | 388| | // Avoid using implementation-defined unsigned to signed conversions. 389| | // To learn more, see https://stackoverflow.com/questions/13150449. 390| 27.4M| if (value <= std::numeric_limits::max()) { ------------------ | Branch (390:7): [True: 26.4M, False: 970k] ------------------ 391| 26.4M| return static_cast(value); 392| 26.4M| } else { 393| 970k| constexpr auto TS_min = std::numeric_limits::min(); 394| 970k| return TS_min + static_cast(value - TS_min); 395| 970k| } 396| 27.4M|} _ZN18FuzzedDataProvider16PickValueInArrayI11BlockStatusEET_St16initializer_listIKS2_E: 316| 29.0k|T FuzzedDataProvider::PickValueInArray(std::initializer_list list) { 317| | // TODO(Dor1s): switch to static_assert once C++14 is allowed. 318| 29.0k| if (!list.size()) ------------------ | Branch (318:7): [True: 0, False: 29.0k] ------------------ 319| 0| abort(); 320| | 321| 29.0k| return *(list.begin() + ConsumeIntegralInRange(0, list.size() - 1)); 322| 29.0k|} _Z17chain_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 15| 489|{ 16| 489| FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); 17| 489| std::optional disk_block_index = ConsumeDeserializable(fuzzed_data_provider); 18| 489| if (!disk_block_index) { ------------------ | Branch (18:9): [True: 301, False: 188] ------------------ 19| 301| return; 20| 301| } 21| | 22| 188| const uint256 zero{}; 23| 188| disk_block_index->phashBlock = &zero; 24| 188| { 25| 188| LOCK(::cs_main); ------------------ | | 257| 188|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 188|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 188|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 188|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 26| 188| (void)disk_block_index->ConstructBlockHash(); 27| 188| (void)disk_block_index->GetBlockPos(); 28| 188| (void)disk_block_index->GetBlockTime(); 29| 188| (void)disk_block_index->GetBlockTimeMax(); 30| 188| (void)disk_block_index->GetMedianTimePast(); 31| 188| (void)disk_block_index->GetUndoPos(); 32| 188| (void)disk_block_index->HaveNumChainTxs(); 33| 188| (void)disk_block_index->IsValid(); 34| 188| } 35| | 36| 188| const CBlockHeader block_header = disk_block_index->GetBlockHeader(); 37| 188| (void)CDiskBlockIndex{*disk_block_index}; 38| 188| (void)disk_block_index->BuildSkip(); 39| | 40| 29.0k| LIMITED_WHILE(fuzzed_data_provider.ConsumeBool(), 10000) { ------------------ | | 23| 29.2k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:34): [True: 29.0k, False: 187] | | | Branch (23:49): [True: 29.0k, False: 1] | | ------------------ ------------------ 41| 29.0k| const BlockStatus block_status = fuzzed_data_provider.PickValueInArray({ 42| 29.0k| BlockStatus::BLOCK_VALID_UNKNOWN, 43| 29.0k| BlockStatus::BLOCK_VALID_RESERVED, 44| 29.0k| BlockStatus::BLOCK_VALID_TREE, 45| 29.0k| BlockStatus::BLOCK_VALID_TRANSACTIONS, 46| 29.0k| BlockStatus::BLOCK_VALID_CHAIN, 47| 29.0k| BlockStatus::BLOCK_VALID_SCRIPTS, 48| 29.0k| BlockStatus::BLOCK_VALID_MASK, 49| 29.0k| BlockStatus::BLOCK_HAVE_DATA, 50| 29.0k| BlockStatus::BLOCK_HAVE_UNDO, 51| 29.0k| BlockStatus::BLOCK_HAVE_MASK, 52| 29.0k| BlockStatus::BLOCK_FAILED_VALID, 53| 29.0k| BlockStatus::BLOCK_FAILED_CHILD, 54| 29.0k| BlockStatus::BLOCK_FAILED_MASK, 55| 29.0k| BlockStatus::BLOCK_OPT_WITNESS, 56| 29.0k| }); 57| 29.0k| if (block_status & ~BLOCK_VALID_MASK) { ------------------ | Branch (57:13): [True: 24.5k, False: 4.51k] ------------------ 58| 24.5k| continue; 59| 24.5k| } 60| 4.51k| WITH_LOCK(::cs_main, (void)disk_block_index->RaiseValidity(block_status)); ------------------ | | 301| 4.51k|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ 61| 4.51k| } 62| | 63| 188| CBlockIndex block_index{block_header}; 64| 188| block_index.phashBlock = &zero; 65| 188| (void)block_index.GetBlockHash(); 66| 188| (void)block_index.ToString(); 67| 188|} LLVMFuzzerTestOneInput: 222| 489|{ 223| 489| test_one_input({data, size}); 224| 489| return 0; 225| 489|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 489|{ 84| 489| CheckGlobals check{}; 85| 489| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 489|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 489|} _Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE: 58| 489|{ 59| 489| static_assert(sizeof(B) == 1); 60| 489| const std::string s = max_length ? ------------------ | Branch (60:27): [True: 0, False: 489] ------------------ 61| 0| fuzzed_data_provider.ConsumeRandomLengthString(*max_length) : 62| 489| fuzzed_data_provider.ConsumeRandomLengthString(); 63| 489| std::vector ret(s.size()); 64| 489| std::copy(s.begin(), s.end(), reinterpret_cast(ret.data())); 65| 489| return ret; 66| 489|} _Z21ConsumeDeserializableI15CDiskBlockIndexENSt3__18optionalIT_EER18FuzzedDataProviderRKNS2_ImEE: 120| 489|{ 121| 489| const std::vector buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length); 122| 489| DataStream ds{buffer}; 123| 489| T obj; 124| 489| try { 125| 489| ds >> obj; 126| 489| } catch (const std::ios_base::failure&) { 127| 301| return std::nullopt; 128| 301| } 129| 188| return obj; 130| 489|} _ZN12CheckGlobalsC2Ev: 56| 489|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 489|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 489| { 18| 489| g_used_g_prng = false; 19| 489| g_seeded_g_prng_zero = false; 20| 489| g_used_system_time = false; 21| 489| SetMockTime(0s); 22| 489| } _ZN16CheckGlobalsImplD2Ev: 24| 489| { 25| 489| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 489] | Branch (25:30): [True: 0, False: 0] ------------------ 26| 0| std::cerr << "\n\n" 27| 0| "The current fuzz target used the global random state.\n\n" 28| | 29| 0| "This is acceptable, but requires the fuzz target to call \n" 30| 0| "SeedRandomStateForTest(SeedRand::ZEROS) in the first line \n" 31| 0| "of the FUZZ_TARGET function.\n\n" 32| | 33| 0| "An alternative solution would be to avoid any use of globals.\n\n" 34| | 35| 0| "Without a solution, fuzz instability and non-determinism can lead \n" 36| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 37| 0| << std::endl; 38| 0| std::abort(); // Abort, because AFL may try to recover from a std::exit 39| 0| } 40| | 41| 489| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 489] ------------------ 42| 0| std::cerr << "\n\n" 43| 0| "The current fuzz target accessed system time.\n\n" 44| | 45| 0| "This is acceptable, but requires the fuzz target to call \n" 46| 0| "SetMockTime() at the beginning of processing the fuzz input.\n\n" 47| | 48| 0| "Without setting mock time, time-dependent behavior can lead \n" 49| 0| "to non-reproducible bugs or inefficient fuzzing.\n\n" 50| 0| << std::endl; 51| 0| std::abort(); 52| 0| } 53| 489| } _ZNK10tinyformat6detail9FormatArg6formatERNSt3__113basic_ostreamIcNS2_11char_traitsIcEEEEPKcS9_i: 541| 752| { 542| 752| TINYFORMAT_ASSERT(m_value); ------------------ | | 153| 752|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ 543| 752| TINYFORMAT_ASSERT(m_formatImpl); ------------------ | | 153| 752|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ 544| 752| m_formatImpl(out, fmtBegin, fmtEnd, ntrunc, m_value); 545| 752| } _ZN10tinyformat10FormatListC2EPNS_6detail9FormatArgEi: 966| 188| : m_args(args), m_N(N) { } _ZN10tinyformat6detail21parseWidthOrPrecisionERiRPKcbPKNS0_9FormatArgES1_i: 593| 752|{ 594| 752| if (*c >= '0' && *c <= '9') { ------------------ | Branch (594:9): [True: 752, False: 0] | Branch (594:22): [True: 0, False: 752] ------------------ 595| 0| n = parseIntAndAdvance(c); 596| 0| } 597| 752| else if (*c == '*') { ------------------ | Branch (597:14): [True: 0, False: 752] ------------------ 598| 0| ++c; 599| 0| n = 0; 600| 0| if (positionalMode) { ------------------ | Branch (600:13): [True: 0, False: 0] ------------------ 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| 0| else { 611| 0| if (argIndex < numArgs) ------------------ | Branch (611:17): [True: 0, False: 0] ------------------ 612| 0| n = args[argIndex++].toInt(); 613| 0| else 614| 0| TINYFORMAT_ERROR("tinyformat: Not enough arguments to read variable width or precision"); ------------------ | | 135| 0|#define TINYFORMAT_ERROR(reasonString) throw tinyformat::format_error(reasonString) ------------------ 615| 0| } 616| 0| } 617| 752| else { 618| 752| return false; 619| 752| } 620| 0| return true; 621| 752|} _ZN10tinyformat6detail24printFormatStringLiteralERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKc: 629| 940|{ 630| 940| const char* c = fmt; 631| 10.3k| for (;; ++c) { 632| 10.3k| if (*c == '\0') { ------------------ | Branch (632:13): [True: 188, False: 10.1k] ------------------ 633| 188| out.write(fmt, c - fmt); 634| 188| return c; 635| 188| } 636| 10.1k| else if (*c == '%') { ------------------ | Branch (636:18): [True: 752, False: 9.40k] ------------------ 637| 752| out.write(fmt, c - fmt); 638| 752| if (*(c+1) != '%') ------------------ | Branch (638:17): [True: 752, False: 0] ------------------ 639| 752| return c; 640| | // for "%%", tack trailing % onto next literal section. 641| 0| fmt = ++c; 642| 0| } 643| 10.3k| } 644| 940|} _ZN10tinyformat6detail21streamStateFromFormatERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEERbS7_RiPKcPKNS0_9FormatArgES8_i: 685| 752|{ 686| 752| TINYFORMAT_ASSERT(*fmtStart == '%'); ------------------ | | 153| 752|# define TINYFORMAT_ASSERT(cond) assert(cond) ------------------ 687| | // Reset stream state to defaults. 688| 752| out.width(0); 689| 752| out.precision(6); 690| 752| out.fill(' '); 691| | // Reset most flags; ignore irrelevant unitbuf & skipws. 692| 752| out.unsetf(std::ios::adjustfield | std::ios::basefield | 693| 752| std::ios::floatfield | std::ios::showbase | std::ios::boolalpha | 694| 752| std::ios::showpoint | std::ios::showpos | std::ios::uppercase); 695| 752| bool precisionSet = false; 696| 752| bool widthSet = false; 697| 752| int widthExtra = 0; 698| 752| 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| 752| if (*c >= '0' && *c <= '9') { ------------------ | Branch (702:9): [True: 752, False: 0] | Branch (702:22): [True: 0, False: 752] ------------------ 703| 0| const char tmpc = *c; 704| 0| int value = parseIntAndAdvance(c); 705| 0| if (*c == '$') { ------------------ | Branch (705:13): [True: 0, False: 0] ------------------ 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| 0| else if (positionalMode) { ------------------ | Branch (714:18): [True: 0, False: 0] ------------------ 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| 0| else { 718| 0| if (tmpc == '0') { ------------------ | Branch (718:17): [True: 0, False: 0] ------------------ 719| | // Use internal padding so that numeric values are 720| | // formatted correctly, eg -00010 rather than 000-10 721| 0| out.fill('0'); 722| 0| out.setf(std::ios::internal, std::ios::adjustfield); 723| 0| } 724| 0| if (value != 0) { ------------------ | Branch (724:17): [True: 0, False: 0] ------------------ 725| | // Nonzero value means that we parsed width. 726| 0| widthSet = true; 727| 0| out.width(value); 728| 0| } 729| 0| } 730| 0| } 731| 752| else if (positionalMode) { ------------------ | Branch (731:14): [True: 0, False: 752] ------------------ 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| 752| if (!widthSet) { ------------------ | Branch (735:9): [True: 752, False: 0] ------------------ 736| | // Parse flags 737| 752| for (;; ++c) { 738| 752| switch (*c) { 739| 0| case '#': ------------------ | Branch (739:17): [True: 0, False: 752] ------------------ 740| 0| out.setf(std::ios::showpoint | std::ios::showbase); 741| 0| continue; 742| 0| case '0': ------------------ | Branch (742:17): [True: 0, False: 752] ------------------ 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: 752] ------------------ 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: 752] ------------------ 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: 752] ------------------ 761| 0| out.setf(std::ios::showpos); 762| 0| spacePadPositive = false; 763| 0| widthExtra = 1; 764| 0| continue; 765| 752| default: ------------------ | Branch (765:17): [True: 752, False: 0] ------------------ 766| 752| break; 767| 752| } 768| 752| break; 769| 752| } 770| | // Parse width 771| 752| int width = 0; 772| 752| widthSet = parseWidthOrPrecision(width, c, positionalMode, 773| 752| args, argIndex, numArgs); 774| 752| if (widthSet) { ------------------ | Branch (774:13): [True: 0, False: 752] ------------------ 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| 752| } 784| | // 3) Parse precision 785| 752| if (*c == '.') { ------------------ | Branch (785:9): [True: 0, False: 752] ------------------ 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| 752| while (*c == 'l' || *c == 'h' || *c == 'L' || ------------------ | Branch (797:12): [True: 0, False: 752] | Branch (797:25): [True: 0, False: 752] | Branch (797:38): [True: 0, False: 752] ------------------ 798| 752| *c == 'j' || *c == 'z' || *c == 't') { ------------------ | Branch (798:12): [True: 0, False: 752] | Branch (798:25): [True: 0, False: 752] | Branch (798:38): [True: 0, False: 752] ------------------ 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| 752| bool intConversion = false; 805| 752| switch (*c) { 806| 188| case 'u': case 'd': case 'i': ------------------ | Branch (806:9): [True: 0, False: 752] | Branch (806:19): [True: 188, False: 564] | Branch (806:29): [True: 0, False: 752] ------------------ 807| 188| out.setf(std::ios::dec, std::ios::basefield); 808| 188| intConversion = true; 809| 188| break; 810| 0| case 'o': ------------------ | Branch (810:9): [True: 0, False: 752] ------------------ 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: 752] ------------------ 815| 0| out.setf(std::ios::uppercase); 816| 0| [[fallthrough]]; 817| 188| case 'x': case 'p': ------------------ | Branch (817:9): [True: 0, False: 752] | Branch (817:19): [True: 188, False: 564] ------------------ 818| 188| out.setf(std::ios::hex, std::ios::basefield); 819| 188| intConversion = true; 820| 188| break; 821| 0| case 'E': ------------------ | Branch (821:9): [True: 0, False: 752] ------------------ 822| 0| out.setf(std::ios::uppercase); 823| 0| [[fallthrough]]; 824| 0| case 'e': ------------------ | Branch (824:9): [True: 0, False: 752] ------------------ 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: 752] ------------------ 829| 0| out.setf(std::ios::uppercase); 830| 0| [[fallthrough]]; 831| 0| case 'f': ------------------ | Branch (831:9): [True: 0, False: 752] ------------------ 832| 0| out.setf(std::ios::fixed, std::ios::floatfield); 833| 0| break; 834| 0| case 'A': ------------------ | Branch (834:9): [True: 0, False: 752] ------------------ 835| 0| out.setf(std::ios::uppercase); 836| 0| [[fallthrough]]; 837| 0| case 'a': ------------------ | Branch (837:9): [True: 0, False: 752] ------------------ 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: 752] ------------------ 847| 0| out.setf(std::ios::uppercase); 848| 0| [[fallthrough]]; 849| 0| case 'g': ------------------ | Branch (849:9): [True: 0, False: 752] ------------------ 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: 752] ------------------ 855| | // Handled as special case inside formatValue() 856| 0| break; 857| 376| case 's': ------------------ | Branch (857:9): [True: 376, False: 376] ------------------ 858| 376| if (precisionSet) ------------------ | Branch (858:17): [True: 0, False: 376] ------------------ 859| 0| ntrunc = static_cast(out.precision()); 860| | // Make %s print Booleans as "true" and "false" 861| 376| out.setf(std::ios::boolalpha); 862| 376| break; 863| 0| case 'n': ------------------ | Branch (863:9): [True: 0, False: 752] ------------------ 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: 752] ------------------ 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: 752] ------------------ 872| 0| break; 873| 752| } 874| 752| if (intConversion && precisionSet && !widthSet) { ------------------ | Branch (874:9): [True: 376, False: 376] | Branch (874:26): [True: 0, False: 376] | 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| 752| return c+1; 884| 752|} _ZN10tinyformat6detail10formatImplERNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcPKNS0_9FormatArgEi: 891| 188|{ 892| | // Saved stream state 893| 188| std::streamsize origWidth = out.width(); 894| 188| std::streamsize origPrecision = out.precision(); 895| 188| std::ios::fmtflags origFlags = out.flags(); 896| 188| 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| 188| bool positionalMode = false; 901| 188| int argIndex = 0; 902| 940| while (true) { ------------------ | Branch (902:12): [Folded - Ignored] ------------------ 903| 940| fmt = printFormatStringLiteral(out, fmt); 904| 940| if (*fmt == '\0') { ------------------ | Branch (904:13): [True: 188, False: 752] ------------------ 905| 188| if (!positionalMode && argIndex < numArgs) { ------------------ | Branch (905:17): [True: 188, False: 0] | Branch (905:36): [True: 0, False: 188] ------------------ 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| 188| break; 909| 188| } 910| 752| bool spacePadPositive = false; 911| 752| int ntrunc = -1; 912| 752| const char* fmtEnd = streamStateFromFormat(out, positionalMode, spacePadPositive, ntrunc, fmt, 913| 752| args, argIndex, numArgs); 914| | // NB: argIndex may be incremented by reading variable width/precision 915| | // in `streamStateFromFormat`, so do the bounds check here. 916| 752| if (argIndex >= numArgs) { ------------------ | Branch (916:13): [True: 0, False: 752] ------------------ 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| 752| const FormatArg& arg = args[argIndex]; 921| | // Format the arg into the stream. 922| 752| if (!spacePadPositive) { ------------------ | Branch (922:13): [True: 752, False: 0] ------------------ 923| 752| arg.format(out, fmt, fmtEnd, ntrunc); 924| 752| } 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| 752| if (!positionalMode) ------------------ | Branch (941:13): [True: 752, False: 0] ------------------ 942| 752| ++argIndex; 943| 752| fmt = fmtEnd; 944| 752| } 945| | 946| | // Restore stream state 947| 188| out.width(origWidth); 948| 188| out.precision(origPrecision); 949| 188| out.flags(origFlags); 950| 188| out.fill(origFill); 951| 188|} _ZN10tinyformat7vformatERNSt3__113basic_ostreamIcNS0_11char_traitsIcEEEEPKcRKNS_10FormatListE: 1070| 188|{ 1071| 188| detail::formatImpl(out, fmt, list.m_args, list.m_N); 1072| 188|} _ZN10tinyformat6detail9FormatArgC2IiEERKT_: 534| 188| : m_value(static_cast(&value)), 535| 188| m_formatImpl(&formatImpl), 536| 188| m_toIntImpl(&toIntImpl) 537| 188| { } _ZN10tinyformat6detail9FormatArg10formatImplIiEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iPKv: 558| 188| { 559| 188| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 188| } _ZN10tinyformat11formatValueIiEEvRNSt3__113basic_ostreamIcNS1_11char_traitsIcEEEEPKcS8_iRKT_: 351| 188|{ 352| 188|#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| 188| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 188| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 188|#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| 188| const bool canConvertToChar = detail::is_convertible::value; 364| 188| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 188| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [Folded - Ignored] | Branch (365:29): [True: 0, False: 188] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 188| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded - Ignored] | 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| 188| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 188] ------------------ 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| 188| else 378| 188| out << value; 379| 188|} _ZN10tinyformat6detail9FormatArgC2INSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERKT_: 534| 376| : m_value(static_cast(&value)), 535| 376| m_formatImpl(&formatImpl), 536| 376| m_toIntImpl(&toIntImpl) 537| 376| { } _ZN10tinyformat6detail9FormatArg10formatImplINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRNS3_13basic_ostreamIcS6_EEPKcSE_iPKv: 558| 376| { 559| 376| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 376| } _ZN10tinyformat11formatValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEvRNS1_13basic_ostreamIcS4_EEPKcSC_iRKT_: 351| 376|{ 352| 376|#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| 376| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 376| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 376|#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| 376| const bool canConvertToChar = detail::is_convertible::value; 364| 376| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 376| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [Folded - Ignored] | Branch (365:29): [True: 0, False: 0] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 376| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded - Ignored] | 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| 376| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 376] ------------------ 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| 376| else 378| 376| out << value; 379| 376|} _ZN10tinyformat6formatIJP11CBlockIndexiNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EEES9_NS_17FormatStringCheckIXsZT_EEEDpRKT_: 1088| 188|{ 1089| 188| std::ostringstream oss; 1090| 188| format(oss, fmt, args...); 1091| 188| return oss.str(); 1092| 188|} _ZN10tinyformat6formatIJP11CBlockIndexiNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EEEvRNS3_13basic_ostreamIcS6_EENS_17FormatStringCheckIXsZT_EEEDpRKT_: 1080| 188|{ 1081| 188| vformat(out, fmt, makeFormatList(args...)); 1082| 188|} _ZN10tinyformat17FormatStringCheckILj4EEcvPKcEv: 197| 188| operator const char*() { return fmt; } _ZN10tinyformat14makeFormatListIJP11CBlockIndexiNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEES9_EEENS_6detail11FormatListNIXsZT_EEEDpRKT_: 1044| 188|{ 1045| 188| return detail::FormatListN(args...); 1046| 188|} _ZN10tinyformat6detail11FormatListNILi4EEC2IJP11CBlockIndexiNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEESC_EEEDpRKT_: 990| 188| : FormatList(&m_formatterStore[0], N), 991| 188| m_formatterStore { FormatArg(args)... } 992| 188| { static_assert(sizeof...(args) == N, "Number of args must be N"); } _ZN10tinyformat6detail9FormatArgC2IP11CBlockIndexEERKT_: 534| 188| : m_value(static_cast(&value)), 535| 188| m_formatImpl(&formatImpl), 536| 188| m_toIntImpl(&toIntImpl) 537| 188| { } _ZN10tinyformat6detail9FormatArg10formatImplIP11CBlockIndexEEvRNSt3__113basic_ostreamIcNS5_11char_traitsIcEEEEPKcSC_iPKv: 558| 188| { 559| 188| formatValue(out, fmtBegin, fmtEnd, ntrunc, *static_cast(value)); 560| 188| } _ZN10tinyformat11formatValueIP11CBlockIndexEEvRNSt3__113basic_ostreamIcNS3_11char_traitsIcEEEEPKcSA_iRKT_: 351| 188|{ 352| 188|#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| 188| typedef typename detail::is_wchar::tinyformat_wchar_is_not_supported DummyType; 356| 188| (void) DummyType(); // avoid unused type warning with gcc-4.8 357| 188|#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| 188| const bool canConvertToChar = detail::is_convertible::value; 364| 188| const bool canConvertToVoidPtr = detail::is_convertible::value; 365| 188| if (canConvertToChar && *(fmtEnd-1) == 'c') ------------------ | Branch (365:9): [Folded - Ignored] | Branch (365:29): [True: 0, False: 0] ------------------ 366| 0| detail::formatValueAsType::invoke(out, value); 367| 188| else if (canConvertToVoidPtr && *(fmtEnd-1) == 'p') ------------------ | Branch (367:14): [Folded - Ignored] | Branch (367:37): [True: 188, False: 0] ------------------ 368| 188| detail::formatValueAsType::invoke(out, value); 369| |#ifdef TINYFORMAT_OLD_LIBSTDCPLUSPLUS_WORKAROUND 370| | else if (detail::formatZeroIntegerWorkaround::invoke(out, value)) /**/; 371| |#endif 372| 0| else if (ntrunc >= 0) { ------------------ | Branch (372:14): [True: 0, False: 0] ------------------ 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| 0| else 378| 0| out << value; 379| 188|} _ZN10tinyformat6detail17formatValueAsTypeIP11CBlockIndexPKvLb1EE6invokeERNSt3__113basic_ostreamIcNS7_11char_traitsIcEEEERKS3_: 264| 188| { out << static_cast(value); } _ZNK9base_blobILj256EE6GetHexEv: 12| 376|{ 13| 376| uint8_t m_data_rev[WIDTH]; 14| 12.4k| for (int i = 0; i < WIDTH; ++i) { ------------------ | Branch (14:21): [True: 12.0k, False: 376] ------------------ 15| 12.0k| m_data_rev[i] = m_data[WIDTH - 1 - i]; 16| 12.0k| } 17| 376| return HexStr(m_data_rev); 18| 376|} _ZNK9base_blobILj256EE8ToStringEv: 48| 376|{ 49| 376| return (GetHex()); 50| 376|} _ZN9base_blobILj256EE5beginEv: 115| 564| constexpr unsigned char* begin() { return m_data.data(); } _ZN9base_blobILj256EE7SetNullEv: 56| 752| { 57| 752| std::fill(m_data.begin(), m_data.end(), 0); 58| 752| } _ZN7uint256C2Ev: 205| 2.59k| constexpr uint256() = default; _ZN9base_blobILj256EEC2Ev: 35| 2.59k| constexpr base_blob() : m_data() {} _ZN9base_blobILj256EE11UnserializeI10DataStreamEEvRT_: 133| 445| { 134| 445| s.read(MakeWritableByteSpan(m_data)); 135| 445| } _ZNK9base_blobILj256EE9SerializeI10HashWriterEEvRT_: 127| 376| { 128| 376| s << Span(m_data); 129| 376| } _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 489|{ 53| 489| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 489| ) { 58| 489| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 489] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 489| } 62| 489| return std::forward(val); 63| 489|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 489|{ 53| 489| if (IS_ASSERT || std::is_constant_evaluated() || G_FUZZING ------------------ | Branch (53:9): [Folded - Ignored] | Branch (53:22): [Folded - Ignored] | Branch (53:54): [Folded - Ignored] ------------------ 54| |#ifdef ABORT_ON_FAILED_ASSUME 55| | || true 56| |#endif 57| 489| ) { 58| 489| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 489] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 489| } 62| 489| return std::forward(val); 63| 489|} _Z16AdditionOverflowImEbT_S0_: 16| 4.52k|{ 17| 4.52k| static_assert(std::is_integral::value, "Integral required."); 18| | if constexpr (std::numeric_limits::is_signed) { 19| | return (i > 0 && j > std::numeric_limits::max() - i) || 20| | (i < 0 && j < std::numeric_limits::min() - i); 21| | } 22| 4.52k| return std::numeric_limits::max() - i < j; 23| 4.52k|} _Z10CheckedAddImENSt3__18optionalIT_EES2_S2_: 27| 4.52k|{ 28| 4.52k| if (AdditionOverflow(i, j)) { ------------------ | Branch (28:9): [True: 0, False: 4.52k] ------------------ 29| 0| return std::nullopt; 30| 0| } 31| 4.52k| return i + j; 32| 4.52k|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 489|{ 43| 489| Assert(mock_time_in >= 0s); ------------------ | | 85| 489|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 489| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 489|}