_ZN20PrefilledTransaction16SerializationOpsI10DataStreamS_17ActionUnserializeEEvRT0_RT_T1_: 79| 1.32k| SERIALIZE_METHODS(PrefilledTransaction, obj) { READWRITE(COMPACTSIZE(obj.index), TX_WITH_WITNESS(Using(obj.tx))); } ------------------ | | 156| 1.32k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN20PrefilledTransaction16SerializationOpsI10DataStreamKS_15ActionSerializeEEvRT0_RT_T1_: 79| 477| SERIALIZE_METHODS(PrefilledTransaction, obj) { READWRITE(COMPACTSIZE(obj.index), TX_WITH_WITNESS(Using(obj.tx))); } ------------------ | | 156| 477|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN11ArgsManagerD2Ev: 134| 2|ArgsManager::~ArgsManager() = default; _ZN11ArgsManager9ClearArgsEv: 362| 2| void ClearArgs() { 363| 2| LOCK(cs_args); ------------------ | | 257| 2|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 2|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 2|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 2|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 364| 2| m_available_args.clear(); 365| 2| m_network_only_args.clear(); 366| 2| } _Z17internal_bswap_32j: 54| 11.2k|{ 55| 11.2k|#ifdef bitcoin_builtin_bswap32 56| 11.2k| return bitcoin_builtin_bswap32(x); ------------------ | | 24| 11.2k|# 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| 11.2k|} _Z17internal_bswap_64m: 64| 1.40k|{ 65| 1.40k|#ifdef bitcoin_builtin_bswap64 66| 1.40k| return bitcoin_builtin_bswap64(x); ------------------ | | 27| 1.40k|# 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| 1.40k|} _Z16htole16_internalt: 19| 1.19k|{ 20| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(host_16bits); 21| 1.19k| else return host_16bits; 22| 1.19k|} _Z16le16toh_internalt: 29| 1.07k|{ 30| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits); 31| 1.07k| else return little_endian_16bits; 32| 1.07k|} _Z16htobe32_internalj: 34| 11.2k|{ 35| 11.2k| if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits); 36| | else return host_32bits; 37| 11.2k|} _Z16htole32_internalj: 39| 224k|{ 40| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(host_32bits); 41| 224k| else return host_32bits; 42| 224k|} _Z16le32toh_internalj: 49| 84.8k|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 84.8k| else return little_endian_32bits; 52| 84.8k|} _Z16htobe64_internalm: 54| 1.40k|{ 55| 1.40k| if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits); 56| | else return host_64bits; 57| 1.40k|} _Z16htole64_internalm: 59| 95.3k|{ 60| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(host_64bits); 61| 95.3k| else return host_64bits; 62| 95.3k|} _Z16le64toh_internalm: 69| 46.9k|{ 70| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits); 71| 46.9k| else return little_endian_64bits; 72| 46.9k|} _ZN15ChaCha20AlignedD2Ev: 43| 2|{ 44| 2| memory_cleanse(input, sizeof(input)); 45| 2|} _ZN8ChaCha20D2Ev: 333| 2|{ 334| 2| memory_cleanse(m_buffer.data(), m_buffer.size()); 335| 2|} _Z9WriteBE32ITk8ByteTypehEvPT_j: 96| 11.2k|{ 97| 11.2k| uint32_t v = htobe32_internal(x); 98| 11.2k| memcpy(ptr, &v, 4); 99| 11.2k|} _Z9WriteBE64ITk8ByteTypehEvPT_m: 103| 1.40k|{ 104| 1.40k| uint64_t v = htobe64_internal(x); 105| 1.40k| memcpy(ptr, &v, 8); 106| 1.40k|} _ZN7CSHA256C2Ev: 697| 704|{ 698| 704| sha256::Initialize(s); 699| 704|} _ZN7CSHA2565WriteEPKhm: 702| 812k|{ 703| 812k| const unsigned char* end = data + len; 704| 812k| size_t bufsize = bytes % 64; 705| 812k| if (bufsize && bufsize + len >= 64) { ------------------ | Branch (705:9): [True: 798k, False: 13.9k] | Branch (705:20): [True: 79.0k, False: 718k] ------------------ 706| | // Fill the buffer, and process it. 707| 79.0k| memcpy(buf + bufsize, data, 64 - bufsize); 708| 79.0k| bytes += 64 - bufsize; 709| 79.0k| data += 64 - bufsize; 710| 79.0k| Transform(s, buf, 1); 711| 79.0k| bufsize = 0; 712| 79.0k| } 713| 812k| if (end - data >= 64) { ------------------ | Branch (713:9): [True: 8.51k, False: 803k] ------------------ 714| 8.51k| size_t blocks = (end - data) / 64; 715| 8.51k| Transform(s, data, blocks); 716| 8.51k| data += 64 * blocks; 717| 8.51k| bytes += 64 * blocks; 718| 8.51k| } 719| 812k| if (end > data) { ------------------ | Branch (719:9): [True: 798k, False: 13.9k] ------------------ 720| | // Fill the buffer with what remains. 721| 798k| memcpy(buf + bufsize, data, end - data); 722| 798k| bytes += end - data; 723| 798k| } 724| 812k| return *this; 725| 812k|} _ZN7CSHA2568FinalizeEPh: 728| 1.40k|{ 729| 1.40k| static const unsigned char pad[64] = {0x80}; 730| 1.40k| unsigned char sizedesc[8]; 731| 1.40k| WriteBE64(sizedesc, bytes << 3); 732| 1.40k| Write(pad, 1 + ((119 - (bytes % 64)) % 64)); 733| 1.40k| Write(sizedesc, 8); 734| 1.40k| WriteBE32(hash, s[0]); 735| 1.40k| WriteBE32(hash + 4, s[1]); 736| 1.40k| WriteBE32(hash + 8, s[2]); 737| 1.40k| WriteBE32(hash + 12, s[3]); 738| 1.40k| WriteBE32(hash + 16, s[4]); 739| 1.40k| WriteBE32(hash + 20, s[5]); 740| 1.40k| WriteBE32(hash + 24, s[6]); 741| 1.40k| WriteBE32(hash + 28, s[7]); 742| 1.40k|} _ZN7CSHA2565ResetEv: 745| 704|{ 746| 704| bytes = 0; 747| 704| sha256::Initialize(s); 748| 704| return *this; 749| 704|} sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj: 89| 1.40k|{ 90| 1.40k| s[0] = 0x6a09e667ul; 91| 1.40k| s[1] = 0xbb67ae85ul; 92| 1.40k| s[2] = 0x3c6ef372ul; 93| 1.40k| s[3] = 0xa54ff53aul; 94| 1.40k| s[4] = 0x510e527ful; 95| 1.40k| s[5] = 0x9b05688cul; 96| 1.40k| s[6] = 0x1f83d9abul; 97| 1.40k| s[7] = 0x5be0cd19ul; 98| 1.40k|} _ZN11sha256_sse49TransformEPjPKhm: 23| 87.5k|{ 24| 87.5k| static const uint32_t K256 alignas(16) [] = { 25| 87.5k| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 26| 87.5k| 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 27| 87.5k| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 28| 87.5k| 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 29| 87.5k| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 30| 87.5k| 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 31| 87.5k| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 32| 87.5k| 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 33| 87.5k| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 34| 87.5k| 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 35| 87.5k| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 36| 87.5k| 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 37| 87.5k| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 38| 87.5k| 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 39| 87.5k| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 40| 87.5k| 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, 41| 87.5k| }; 42| 87.5k| static const uint32_t FLIP_MASK alignas(16) [] = {0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f}; 43| 87.5k| static const uint32_t SHUF_00BA alignas(16) [] = {0x03020100, 0x0b0a0908, 0xffffffff, 0xffffffff}; 44| 87.5k| static const uint32_t SHUF_DC00 alignas(16) [] = {0xffffffff, 0xffffffff, 0x03020100, 0x0b0a0908}; 45| 87.5k| uint32_t a, b, c, d, f, g, h, y0, y1, y2; 46| 87.5k| uint64_t tbl; 47| 87.5k| uint64_t inp_end, inp; 48| 87.5k| uint32_t xfer alignas(16) [4]; 49| | 50| 87.5k| __asm__ __volatile__( 51| 87.5k| "shl $0x6,%2;" 52| 87.5k| "je Ldone_hash_%=;" 53| 87.5k| "add %1,%2;" 54| 87.5k| "mov %2,%14;" 55| 87.5k| "mov (%0),%3;" 56| 87.5k| "mov 0x4(%0),%4;" 57| 87.5k| "mov 0x8(%0),%5;" 58| 87.5k| "mov 0xc(%0),%6;" 59| 87.5k| "mov 0x10(%0),%k2;" 60| 87.5k| "mov 0x14(%0),%7;" 61| 87.5k| "mov 0x18(%0),%8;" 62| 87.5k| "mov 0x1c(%0),%9;" 63| 87.5k| "movdqa %18,%%xmm12;" 64| 87.5k| "movdqa %19,%%xmm10;" 65| 87.5k| "movdqa %20,%%xmm11;" 66| | 67| 87.5k| "Lloop0_%=:" 68| 87.5k| "lea %17,%13;" 69| 87.5k| "movdqu (%1),%%xmm4;" 70| 87.5k| "pshufb %%xmm12,%%xmm4;" 71| 87.5k| "movdqu 0x10(%1),%%xmm5;" 72| 87.5k| "pshufb %%xmm12,%%xmm5;" 73| 87.5k| "movdqu 0x20(%1),%%xmm6;" 74| 87.5k| "pshufb %%xmm12,%%xmm6;" 75| 87.5k| "movdqu 0x30(%1),%%xmm7;" 76| 87.5k| "pshufb %%xmm12,%%xmm7;" 77| 87.5k| "mov %1,%15;" 78| 87.5k| "mov $3,%1;" 79| | 80| 87.5k| "Lloop1_%=:" 81| 87.5k| "movdqa 0x0(%13),%%xmm9;" 82| 87.5k| "paddd %%xmm4,%%xmm9;" 83| 87.5k| "movdqa %%xmm9,%16;" 84| 87.5k| "movdqa %%xmm7,%%xmm0;" 85| 87.5k| "mov %k2,%10;" 86| 87.5k| "ror $0xe,%10;" 87| 87.5k| "mov %3,%11;" 88| 87.5k| "palignr $0x4,%%xmm6,%%xmm0;" 89| 87.5k| "ror $0x9,%11;" 90| 87.5k| "xor %k2,%10;" 91| 87.5k| "mov %7,%12;" 92| 87.5k| "ror $0x5,%10;" 93| 87.5k| "movdqa %%xmm5,%%xmm1;" 94| 87.5k| "xor %3,%11;" 95| 87.5k| "xor %8,%12;" 96| 87.5k| "paddd %%xmm4,%%xmm0;" 97| 87.5k| "xor %k2,%10;" 98| 87.5k| "and %k2,%12;" 99| 87.5k| "ror $0xb,%11;" 100| 87.5k| "palignr $0x4,%%xmm4,%%xmm1;" 101| 87.5k| "xor %3,%11;" 102| 87.5k| "ror $0x6,%10;" 103| 87.5k| "xor %8,%12;" 104| 87.5k| "movdqa %%xmm1,%%xmm2;" 105| 87.5k| "ror $0x2,%11;" 106| 87.5k| "add %10,%12;" 107| 87.5k| "add %16,%12;" 108| 87.5k| "movdqa %%xmm1,%%xmm3;" 109| 87.5k| "mov %3,%10;" 110| 87.5k| "add %12,%9;" 111| 87.5k| "mov %3,%12;" 112| 87.5k| "pslld $0x19,%%xmm1;" 113| 87.5k| "or %5,%10;" 114| 87.5k| "add %9,%6;" 115| 87.5k| "and %5,%12;" 116| 87.5k| "psrld $0x7,%%xmm2;" 117| 87.5k| "and %4,%10;" 118| 87.5k| "add %11,%9;" 119| 87.5k| "por %%xmm2,%%xmm1;" 120| 87.5k| "or %12,%10;" 121| 87.5k| "add %10,%9;" 122| 87.5k| "movdqa %%xmm3,%%xmm2;" 123| 87.5k| "mov %6,%10;" 124| 87.5k| "mov %9,%11;" 125| 87.5k| "movdqa %%xmm3,%%xmm8;" 126| 87.5k| "ror $0xe,%10;" 127| 87.5k| "xor %6,%10;" 128| 87.5k| "mov %k2,%12;" 129| 87.5k| "ror $0x9,%11;" 130| 87.5k| "pslld $0xe,%%xmm3;" 131| 87.5k| "xor %9,%11;" 132| 87.5k| "ror $0x5,%10;" 133| 87.5k| "xor %7,%12;" 134| 87.5k| "psrld $0x12,%%xmm2;" 135| 87.5k| "ror $0xb,%11;" 136| 87.5k| "xor %6,%10;" 137| 87.5k| "and %6,%12;" 138| 87.5k| "ror $0x6,%10;" 139| 87.5k| "pxor %%xmm3,%%xmm1;" 140| 87.5k| "xor %9,%11;" 141| 87.5k| "xor %7,%12;" 142| 87.5k| "psrld $0x3,%%xmm8;" 143| 87.5k| "add %10,%12;" 144| 87.5k| "add 4+%16,%12;" 145| 87.5k| "ror $0x2,%11;" 146| 87.5k| "pxor %%xmm2,%%xmm1;" 147| 87.5k| "mov %9,%10;" 148| 87.5k| "add %12,%8;" 149| 87.5k| "mov %9,%12;" 150| 87.5k| "pxor %%xmm8,%%xmm1;" 151| 87.5k| "or %4,%10;" 152| 87.5k| "add %8,%5;" 153| 87.5k| "and %4,%12;" 154| 87.5k| "pshufd $0xfa,%%xmm7,%%xmm2;" 155| 87.5k| "and %3,%10;" 156| 87.5k| "add %11,%8;" 157| 87.5k| "paddd %%xmm1,%%xmm0;" 158| 87.5k| "or %12,%10;" 159| 87.5k| "add %10,%8;" 160| 87.5k| "movdqa %%xmm2,%%xmm3;" 161| 87.5k| "mov %5,%10;" 162| 87.5k| "mov %8,%11;" 163| 87.5k| "ror $0xe,%10;" 164| 87.5k| "movdqa %%xmm2,%%xmm8;" 165| 87.5k| "xor %5,%10;" 166| 87.5k| "ror $0x9,%11;" 167| 87.5k| "mov %6,%12;" 168| 87.5k| "xor %8,%11;" 169| 87.5k| "ror $0x5,%10;" 170| 87.5k| "psrlq $0x11,%%xmm2;" 171| 87.5k| "xor %k2,%12;" 172| 87.5k| "psrlq $0x13,%%xmm3;" 173| 87.5k| "xor %5,%10;" 174| 87.5k| "and %5,%12;" 175| 87.5k| "psrld $0xa,%%xmm8;" 176| 87.5k| "ror $0xb,%11;" 177| 87.5k| "xor %8,%11;" 178| 87.5k| "xor %k2,%12;" 179| 87.5k| "ror $0x6,%10;" 180| 87.5k| "pxor %%xmm3,%%xmm2;" 181| 87.5k| "add %10,%12;" 182| 87.5k| "ror $0x2,%11;" 183| 87.5k| "add 8+%16,%12;" 184| 87.5k| "pxor %%xmm2,%%xmm8;" 185| 87.5k| "mov %8,%10;" 186| 87.5k| "add %12,%7;" 187| 87.5k| "mov %8,%12;" 188| 87.5k| "pshufb %%xmm10,%%xmm8;" 189| 87.5k| "or %3,%10;" 190| 87.5k| "add %7,%4;" 191| 87.5k| "and %3,%12;" 192| 87.5k| "paddd %%xmm8,%%xmm0;" 193| 87.5k| "and %9,%10;" 194| 87.5k| "add %11,%7;" 195| 87.5k| "pshufd $0x50,%%xmm0,%%xmm2;" 196| 87.5k| "or %12,%10;" 197| 87.5k| "add %10,%7;" 198| 87.5k| "movdqa %%xmm2,%%xmm3;" 199| 87.5k| "mov %4,%10;" 200| 87.5k| "ror $0xe,%10;" 201| 87.5k| "mov %7,%11;" 202| 87.5k| "movdqa %%xmm2,%%xmm4;" 203| 87.5k| "ror $0x9,%11;" 204| 87.5k| "xor %4,%10;" 205| 87.5k| "mov %5,%12;" 206| 87.5k| "ror $0x5,%10;" 207| 87.5k| "psrlq $0x11,%%xmm2;" 208| 87.5k| "xor %7,%11;" 209| 87.5k| "xor %6,%12;" 210| 87.5k| "psrlq $0x13,%%xmm3;" 211| 87.5k| "xor %4,%10;" 212| 87.5k| "and %4,%12;" 213| 87.5k| "ror $0xb,%11;" 214| 87.5k| "psrld $0xa,%%xmm4;" 215| 87.5k| "xor %7,%11;" 216| 87.5k| "ror $0x6,%10;" 217| 87.5k| "xor %6,%12;" 218| 87.5k| "pxor %%xmm3,%%xmm2;" 219| 87.5k| "ror $0x2,%11;" 220| 87.5k| "add %10,%12;" 221| 87.5k| "add 12+%16,%12;" 222| 87.5k| "pxor %%xmm2,%%xmm4;" 223| 87.5k| "mov %7,%10;" 224| 87.5k| "add %12,%k2;" 225| 87.5k| "mov %7,%12;" 226| 87.5k| "pshufb %%xmm11,%%xmm4;" 227| 87.5k| "or %9,%10;" 228| 87.5k| "add %k2,%3;" 229| 87.5k| "and %9,%12;" 230| 87.5k| "paddd %%xmm0,%%xmm4;" 231| 87.5k| "and %8,%10;" 232| 87.5k| "add %11,%k2;" 233| 87.5k| "or %12,%10;" 234| 87.5k| "add %10,%k2;" 235| 87.5k| "movdqa 0x10(%13),%%xmm9;" 236| 87.5k| "paddd %%xmm5,%%xmm9;" 237| 87.5k| "movdqa %%xmm9,%16;" 238| 87.5k| "movdqa %%xmm4,%%xmm0;" 239| 87.5k| "mov %3,%10;" 240| 87.5k| "ror $0xe,%10;" 241| 87.5k| "mov %k2,%11;" 242| 87.5k| "palignr $0x4,%%xmm7,%%xmm0;" 243| 87.5k| "ror $0x9,%11;" 244| 87.5k| "xor %3,%10;" 245| 87.5k| "mov %4,%12;" 246| 87.5k| "ror $0x5,%10;" 247| 87.5k| "movdqa %%xmm6,%%xmm1;" 248| 87.5k| "xor %k2,%11;" 249| 87.5k| "xor %5,%12;" 250| 87.5k| "paddd %%xmm5,%%xmm0;" 251| 87.5k| "xor %3,%10;" 252| 87.5k| "and %3,%12;" 253| 87.5k| "ror $0xb,%11;" 254| 87.5k| "palignr $0x4,%%xmm5,%%xmm1;" 255| 87.5k| "xor %k2,%11;" 256| 87.5k| "ror $0x6,%10;" 257| 87.5k| "xor %5,%12;" 258| 87.5k| "movdqa %%xmm1,%%xmm2;" 259| 87.5k| "ror $0x2,%11;" 260| 87.5k| "add %10,%12;" 261| 87.5k| "add %16,%12;" 262| 87.5k| "movdqa %%xmm1,%%xmm3;" 263| 87.5k| "mov %k2,%10;" 264| 87.5k| "add %12,%6;" 265| 87.5k| "mov %k2,%12;" 266| 87.5k| "pslld $0x19,%%xmm1;" 267| 87.5k| "or %8,%10;" 268| 87.5k| "add %6,%9;" 269| 87.5k| "and %8,%12;" 270| 87.5k| "psrld $0x7,%%xmm2;" 271| 87.5k| "and %7,%10;" 272| 87.5k| "add %11,%6;" 273| 87.5k| "por %%xmm2,%%xmm1;" 274| 87.5k| "or %12,%10;" 275| 87.5k| "add %10,%6;" 276| 87.5k| "movdqa %%xmm3,%%xmm2;" 277| 87.5k| "mov %9,%10;" 278| 87.5k| "mov %6,%11;" 279| 87.5k| "movdqa %%xmm3,%%xmm8;" 280| 87.5k| "ror $0xe,%10;" 281| 87.5k| "xor %9,%10;" 282| 87.5k| "mov %3,%12;" 283| 87.5k| "ror $0x9,%11;" 284| 87.5k| "pslld $0xe,%%xmm3;" 285| 87.5k| "xor %6,%11;" 286| 87.5k| "ror $0x5,%10;" 287| 87.5k| "xor %4,%12;" 288| 87.5k| "psrld $0x12,%%xmm2;" 289| 87.5k| "ror $0xb,%11;" 290| 87.5k| "xor %9,%10;" 291| 87.5k| "and %9,%12;" 292| 87.5k| "ror $0x6,%10;" 293| 87.5k| "pxor %%xmm3,%%xmm1;" 294| 87.5k| "xor %6,%11;" 295| 87.5k| "xor %4,%12;" 296| 87.5k| "psrld $0x3,%%xmm8;" 297| 87.5k| "add %10,%12;" 298| 87.5k| "add 4+%16,%12;" 299| 87.5k| "ror $0x2,%11;" 300| 87.5k| "pxor %%xmm2,%%xmm1;" 301| 87.5k| "mov %6,%10;" 302| 87.5k| "add %12,%5;" 303| 87.5k| "mov %6,%12;" 304| 87.5k| "pxor %%xmm8,%%xmm1;" 305| 87.5k| "or %7,%10;" 306| 87.5k| "add %5,%8;" 307| 87.5k| "and %7,%12;" 308| 87.5k| "pshufd $0xfa,%%xmm4,%%xmm2;" 309| 87.5k| "and %k2,%10;" 310| 87.5k| "add %11,%5;" 311| 87.5k| "paddd %%xmm1,%%xmm0;" 312| 87.5k| "or %12,%10;" 313| 87.5k| "add %10,%5;" 314| 87.5k| "movdqa %%xmm2,%%xmm3;" 315| 87.5k| "mov %8,%10;" 316| 87.5k| "mov %5,%11;" 317| 87.5k| "ror $0xe,%10;" 318| 87.5k| "movdqa %%xmm2,%%xmm8;" 319| 87.5k| "xor %8,%10;" 320| 87.5k| "ror $0x9,%11;" 321| 87.5k| "mov %9,%12;" 322| 87.5k| "xor %5,%11;" 323| 87.5k| "ror $0x5,%10;" 324| 87.5k| "psrlq $0x11,%%xmm2;" 325| 87.5k| "xor %3,%12;" 326| 87.5k| "psrlq $0x13,%%xmm3;" 327| 87.5k| "xor %8,%10;" 328| 87.5k| "and %8,%12;" 329| 87.5k| "psrld $0xa,%%xmm8;" 330| 87.5k| "ror $0xb,%11;" 331| 87.5k| "xor %5,%11;" 332| 87.5k| "xor %3,%12;" 333| 87.5k| "ror $0x6,%10;" 334| 87.5k| "pxor %%xmm3,%%xmm2;" 335| 87.5k| "add %10,%12;" 336| 87.5k| "ror $0x2,%11;" 337| 87.5k| "add 8+%16,%12;" 338| 87.5k| "pxor %%xmm2,%%xmm8;" 339| 87.5k| "mov %5,%10;" 340| 87.5k| "add %12,%4;" 341| 87.5k| "mov %5,%12;" 342| 87.5k| "pshufb %%xmm10,%%xmm8;" 343| 87.5k| "or %k2,%10;" 344| 87.5k| "add %4,%7;" 345| 87.5k| "and %k2,%12;" 346| 87.5k| "paddd %%xmm8,%%xmm0;" 347| 87.5k| "and %6,%10;" 348| 87.5k| "add %11,%4;" 349| 87.5k| "pshufd $0x50,%%xmm0,%%xmm2;" 350| 87.5k| "or %12,%10;" 351| 87.5k| "add %10,%4;" 352| 87.5k| "movdqa %%xmm2,%%xmm3;" 353| 87.5k| "mov %7,%10;" 354| 87.5k| "ror $0xe,%10;" 355| 87.5k| "mov %4,%11;" 356| 87.5k| "movdqa %%xmm2,%%xmm5;" 357| 87.5k| "ror $0x9,%11;" 358| 87.5k| "xor %7,%10;" 359| 87.5k| "mov %8,%12;" 360| 87.5k| "ror $0x5,%10;" 361| 87.5k| "psrlq $0x11,%%xmm2;" 362| 87.5k| "xor %4,%11;" 363| 87.5k| "xor %9,%12;" 364| 87.5k| "psrlq $0x13,%%xmm3;" 365| 87.5k| "xor %7,%10;" 366| 87.5k| "and %7,%12;" 367| 87.5k| "ror $0xb,%11;" 368| 87.5k| "psrld $0xa,%%xmm5;" 369| 87.5k| "xor %4,%11;" 370| 87.5k| "ror $0x6,%10;" 371| 87.5k| "xor %9,%12;" 372| 87.5k| "pxor %%xmm3,%%xmm2;" 373| 87.5k| "ror $0x2,%11;" 374| 87.5k| "add %10,%12;" 375| 87.5k| "add 12+%16,%12;" 376| 87.5k| "pxor %%xmm2,%%xmm5;" 377| 87.5k| "mov %4,%10;" 378| 87.5k| "add %12,%3;" 379| 87.5k| "mov %4,%12;" 380| 87.5k| "pshufb %%xmm11,%%xmm5;" 381| 87.5k| "or %6,%10;" 382| 87.5k| "add %3,%k2;" 383| 87.5k| "and %6,%12;" 384| 87.5k| "paddd %%xmm0,%%xmm5;" 385| 87.5k| "and %5,%10;" 386| 87.5k| "add %11,%3;" 387| 87.5k| "or %12,%10;" 388| 87.5k| "add %10,%3;" 389| 87.5k| "movdqa 0x20(%13),%%xmm9;" 390| 87.5k| "paddd %%xmm6,%%xmm9;" 391| 87.5k| "movdqa %%xmm9,%16;" 392| 87.5k| "movdqa %%xmm5,%%xmm0;" 393| 87.5k| "mov %k2,%10;" 394| 87.5k| "ror $0xe,%10;" 395| 87.5k| "mov %3,%11;" 396| 87.5k| "palignr $0x4,%%xmm4,%%xmm0;" 397| 87.5k| "ror $0x9,%11;" 398| 87.5k| "xor %k2,%10;" 399| 87.5k| "mov %7,%12;" 400| 87.5k| "ror $0x5,%10;" 401| 87.5k| "movdqa %%xmm7,%%xmm1;" 402| 87.5k| "xor %3,%11;" 403| 87.5k| "xor %8,%12;" 404| 87.5k| "paddd %%xmm6,%%xmm0;" 405| 87.5k| "xor %k2,%10;" 406| 87.5k| "and %k2,%12;" 407| 87.5k| "ror $0xb,%11;" 408| 87.5k| "palignr $0x4,%%xmm6,%%xmm1;" 409| 87.5k| "xor %3,%11;" 410| 87.5k| "ror $0x6,%10;" 411| 87.5k| "xor %8,%12;" 412| 87.5k| "movdqa %%xmm1,%%xmm2;" 413| 87.5k| "ror $0x2,%11;" 414| 87.5k| "add %10,%12;" 415| 87.5k| "add %16,%12;" 416| 87.5k| "movdqa %%xmm1,%%xmm3;" 417| 87.5k| "mov %3,%10;" 418| 87.5k| "add %12,%9;" 419| 87.5k| "mov %3,%12;" 420| 87.5k| "pslld $0x19,%%xmm1;" 421| 87.5k| "or %5,%10;" 422| 87.5k| "add %9,%6;" 423| 87.5k| "and %5,%12;" 424| 87.5k| "psrld $0x7,%%xmm2;" 425| 87.5k| "and %4,%10;" 426| 87.5k| "add %11,%9;" 427| 87.5k| "por %%xmm2,%%xmm1;" 428| 87.5k| "or %12,%10;" 429| 87.5k| "add %10,%9;" 430| 87.5k| "movdqa %%xmm3,%%xmm2;" 431| 87.5k| "mov %6,%10;" 432| 87.5k| "mov %9,%11;" 433| 87.5k| "movdqa %%xmm3,%%xmm8;" 434| 87.5k| "ror $0xe,%10;" 435| 87.5k| "xor %6,%10;" 436| 87.5k| "mov %k2,%12;" 437| 87.5k| "ror $0x9,%11;" 438| 87.5k| "pslld $0xe,%%xmm3;" 439| 87.5k| "xor %9,%11;" 440| 87.5k| "ror $0x5,%10;" 441| 87.5k| "xor %7,%12;" 442| 87.5k| "psrld $0x12,%%xmm2;" 443| 87.5k| "ror $0xb,%11;" 444| 87.5k| "xor %6,%10;" 445| 87.5k| "and %6,%12;" 446| 87.5k| "ror $0x6,%10;" 447| 87.5k| "pxor %%xmm3,%%xmm1;" 448| 87.5k| "xor %9,%11;" 449| 87.5k| "xor %7,%12;" 450| 87.5k| "psrld $0x3,%%xmm8;" 451| 87.5k| "add %10,%12;" 452| 87.5k| "add 4+%16,%12;" 453| 87.5k| "ror $0x2,%11;" 454| 87.5k| "pxor %%xmm2,%%xmm1;" 455| 87.5k| "mov %9,%10;" 456| 87.5k| "add %12,%8;" 457| 87.5k| "mov %9,%12;" 458| 87.5k| "pxor %%xmm8,%%xmm1;" 459| 87.5k| "or %4,%10;" 460| 87.5k| "add %8,%5;" 461| 87.5k| "and %4,%12;" 462| 87.5k| "pshufd $0xfa,%%xmm5,%%xmm2;" 463| 87.5k| "and %3,%10;" 464| 87.5k| "add %11,%8;" 465| 87.5k| "paddd %%xmm1,%%xmm0;" 466| 87.5k| "or %12,%10;" 467| 87.5k| "add %10,%8;" 468| 87.5k| "movdqa %%xmm2,%%xmm3;" 469| 87.5k| "mov %5,%10;" 470| 87.5k| "mov %8,%11;" 471| 87.5k| "ror $0xe,%10;" 472| 87.5k| "movdqa %%xmm2,%%xmm8;" 473| 87.5k| "xor %5,%10;" 474| 87.5k| "ror $0x9,%11;" 475| 87.5k| "mov %6,%12;" 476| 87.5k| "xor %8,%11;" 477| 87.5k| "ror $0x5,%10;" 478| 87.5k| "psrlq $0x11,%%xmm2;" 479| 87.5k| "xor %k2,%12;" 480| 87.5k| "psrlq $0x13,%%xmm3;" 481| 87.5k| "xor %5,%10;" 482| 87.5k| "and %5,%12;" 483| 87.5k| "psrld $0xa,%%xmm8;" 484| 87.5k| "ror $0xb,%11;" 485| 87.5k| "xor %8,%11;" 486| 87.5k| "xor %k2,%12;" 487| 87.5k| "ror $0x6,%10;" 488| 87.5k| "pxor %%xmm3,%%xmm2;" 489| 87.5k| "add %10,%12;" 490| 87.5k| "ror $0x2,%11;" 491| 87.5k| "add 8+%16,%12;" 492| 87.5k| "pxor %%xmm2,%%xmm8;" 493| 87.5k| "mov %8,%10;" 494| 87.5k| "add %12,%7;" 495| 87.5k| "mov %8,%12;" 496| 87.5k| "pshufb %%xmm10,%%xmm8;" 497| 87.5k| "or %3,%10;" 498| 87.5k| "add %7,%4;" 499| 87.5k| "and %3,%12;" 500| 87.5k| "paddd %%xmm8,%%xmm0;" 501| 87.5k| "and %9,%10;" 502| 87.5k| "add %11,%7;" 503| 87.5k| "pshufd $0x50,%%xmm0,%%xmm2;" 504| 87.5k| "or %12,%10;" 505| 87.5k| "add %10,%7;" 506| 87.5k| "movdqa %%xmm2,%%xmm3;" 507| 87.5k| "mov %4,%10;" 508| 87.5k| "ror $0xe,%10;" 509| 87.5k| "mov %7,%11;" 510| 87.5k| "movdqa %%xmm2,%%xmm6;" 511| 87.5k| "ror $0x9,%11;" 512| 87.5k| "xor %4,%10;" 513| 87.5k| "mov %5,%12;" 514| 87.5k| "ror $0x5,%10;" 515| 87.5k| "psrlq $0x11,%%xmm2;" 516| 87.5k| "xor %7,%11;" 517| 87.5k| "xor %6,%12;" 518| 87.5k| "psrlq $0x13,%%xmm3;" 519| 87.5k| "xor %4,%10;" 520| 87.5k| "and %4,%12;" 521| 87.5k| "ror $0xb,%11;" 522| 87.5k| "psrld $0xa,%%xmm6;" 523| 87.5k| "xor %7,%11;" 524| 87.5k| "ror $0x6,%10;" 525| 87.5k| "xor %6,%12;" 526| 87.5k| "pxor %%xmm3,%%xmm2;" 527| 87.5k| "ror $0x2,%11;" 528| 87.5k| "add %10,%12;" 529| 87.5k| "add 12+%16,%12;" 530| 87.5k| "pxor %%xmm2,%%xmm6;" 531| 87.5k| "mov %7,%10;" 532| 87.5k| "add %12,%k2;" 533| 87.5k| "mov %7,%12;" 534| 87.5k| "pshufb %%xmm11,%%xmm6;" 535| 87.5k| "or %9,%10;" 536| 87.5k| "add %k2,%3;" 537| 87.5k| "and %9,%12;" 538| 87.5k| "paddd %%xmm0,%%xmm6;" 539| 87.5k| "and %8,%10;" 540| 87.5k| "add %11,%k2;" 541| 87.5k| "or %12,%10;" 542| 87.5k| "add %10,%k2;" 543| 87.5k| "movdqa 0x30(%13),%%xmm9;" 544| 87.5k| "paddd %%xmm7,%%xmm9;" 545| 87.5k| "movdqa %%xmm9,%16;" 546| 87.5k| "add $0x40,%13;" 547| 87.5k| "movdqa %%xmm6,%%xmm0;" 548| 87.5k| "mov %3,%10;" 549| 87.5k| "ror $0xe,%10;" 550| 87.5k| "mov %k2,%11;" 551| 87.5k| "palignr $0x4,%%xmm5,%%xmm0;" 552| 87.5k| "ror $0x9,%11;" 553| 87.5k| "xor %3,%10;" 554| 87.5k| "mov %4,%12;" 555| 87.5k| "ror $0x5,%10;" 556| 87.5k| "movdqa %%xmm4,%%xmm1;" 557| 87.5k| "xor %k2,%11;" 558| 87.5k| "xor %5,%12;" 559| 87.5k| "paddd %%xmm7,%%xmm0;" 560| 87.5k| "xor %3,%10;" 561| 87.5k| "and %3,%12;" 562| 87.5k| "ror $0xb,%11;" 563| 87.5k| "palignr $0x4,%%xmm7,%%xmm1;" 564| 87.5k| "xor %k2,%11;" 565| 87.5k| "ror $0x6,%10;" 566| 87.5k| "xor %5,%12;" 567| 87.5k| "movdqa %%xmm1,%%xmm2;" 568| 87.5k| "ror $0x2,%11;" 569| 87.5k| "add %10,%12;" 570| 87.5k| "add %16,%12;" 571| 87.5k| "movdqa %%xmm1,%%xmm3;" 572| 87.5k| "mov %k2,%10;" 573| 87.5k| "add %12,%6;" 574| 87.5k| "mov %k2,%12;" 575| 87.5k| "pslld $0x19,%%xmm1;" 576| 87.5k| "or %8,%10;" 577| 87.5k| "add %6,%9;" 578| 87.5k| "and %8,%12;" 579| 87.5k| "psrld $0x7,%%xmm2;" 580| 87.5k| "and %7,%10;" 581| 87.5k| "add %11,%6;" 582| 87.5k| "por %%xmm2,%%xmm1;" 583| 87.5k| "or %12,%10;" 584| 87.5k| "add %10,%6;" 585| 87.5k| "movdqa %%xmm3,%%xmm2;" 586| 87.5k| "mov %9,%10;" 587| 87.5k| "mov %6,%11;" 588| 87.5k| "movdqa %%xmm3,%%xmm8;" 589| 87.5k| "ror $0xe,%10;" 590| 87.5k| "xor %9,%10;" 591| 87.5k| "mov %3,%12;" 592| 87.5k| "ror $0x9,%11;" 593| 87.5k| "pslld $0xe,%%xmm3;" 594| 87.5k| "xor %6,%11;" 595| 87.5k| "ror $0x5,%10;" 596| 87.5k| "xor %4,%12;" 597| 87.5k| "psrld $0x12,%%xmm2;" 598| 87.5k| "ror $0xb,%11;" 599| 87.5k| "xor %9,%10;" 600| 87.5k| "and %9,%12;" 601| 87.5k| "ror $0x6,%10;" 602| 87.5k| "pxor %%xmm3,%%xmm1;" 603| 87.5k| "xor %6,%11;" 604| 87.5k| "xor %4,%12;" 605| 87.5k| "psrld $0x3,%%xmm8;" 606| 87.5k| "add %10,%12;" 607| 87.5k| "add 4+%16,%12;" 608| 87.5k| "ror $0x2,%11;" 609| 87.5k| "pxor %%xmm2,%%xmm1;" 610| 87.5k| "mov %6,%10;" 611| 87.5k| "add %12,%5;" 612| 87.5k| "mov %6,%12;" 613| 87.5k| "pxor %%xmm8,%%xmm1;" 614| 87.5k| "or %7,%10;" 615| 87.5k| "add %5,%8;" 616| 87.5k| "and %7,%12;" 617| 87.5k| "pshufd $0xfa,%%xmm6,%%xmm2;" 618| 87.5k| "and %k2,%10;" 619| 87.5k| "add %11,%5;" 620| 87.5k| "paddd %%xmm1,%%xmm0;" 621| 87.5k| "or %12,%10;" 622| 87.5k| "add %10,%5;" 623| 87.5k| "movdqa %%xmm2,%%xmm3;" 624| 87.5k| "mov %8,%10;" 625| 87.5k| "mov %5,%11;" 626| 87.5k| "ror $0xe,%10;" 627| 87.5k| "movdqa %%xmm2,%%xmm8;" 628| 87.5k| "xor %8,%10;" 629| 87.5k| "ror $0x9,%11;" 630| 87.5k| "mov %9,%12;" 631| 87.5k| "xor %5,%11;" 632| 87.5k| "ror $0x5,%10;" 633| 87.5k| "psrlq $0x11,%%xmm2;" 634| 87.5k| "xor %3,%12;" 635| 87.5k| "psrlq $0x13,%%xmm3;" 636| 87.5k| "xor %8,%10;" 637| 87.5k| "and %8,%12;" 638| 87.5k| "psrld $0xa,%%xmm8;" 639| 87.5k| "ror $0xb,%11;" 640| 87.5k| "xor %5,%11;" 641| 87.5k| "xor %3,%12;" 642| 87.5k| "ror $0x6,%10;" 643| 87.5k| "pxor %%xmm3,%%xmm2;" 644| 87.5k| "add %10,%12;" 645| 87.5k| "ror $0x2,%11;" 646| 87.5k| "add 8+%16,%12;" 647| 87.5k| "pxor %%xmm2,%%xmm8;" 648| 87.5k| "mov %5,%10;" 649| 87.5k| "add %12,%4;" 650| 87.5k| "mov %5,%12;" 651| 87.5k| "pshufb %%xmm10,%%xmm8;" 652| 87.5k| "or %k2,%10;" 653| 87.5k| "add %4,%7;" 654| 87.5k| "and %k2,%12;" 655| 87.5k| "paddd %%xmm8,%%xmm0;" 656| 87.5k| "and %6,%10;" 657| 87.5k| "add %11,%4;" 658| 87.5k| "pshufd $0x50,%%xmm0,%%xmm2;" 659| 87.5k| "or %12,%10;" 660| 87.5k| "add %10,%4;" 661| 87.5k| "movdqa %%xmm2,%%xmm3;" 662| 87.5k| "mov %7,%10;" 663| 87.5k| "ror $0xe,%10;" 664| 87.5k| "mov %4,%11;" 665| 87.5k| "movdqa %%xmm2,%%xmm7;" 666| 87.5k| "ror $0x9,%11;" 667| 87.5k| "xor %7,%10;" 668| 87.5k| "mov %8,%12;" 669| 87.5k| "ror $0x5,%10;" 670| 87.5k| "psrlq $0x11,%%xmm2;" 671| 87.5k| "xor %4,%11;" 672| 87.5k| "xor %9,%12;" 673| 87.5k| "psrlq $0x13,%%xmm3;" 674| 87.5k| "xor %7,%10;" 675| 87.5k| "and %7,%12;" 676| 87.5k| "ror $0xb,%11;" 677| 87.5k| "psrld $0xa,%%xmm7;" 678| 87.5k| "xor %4,%11;" 679| 87.5k| "ror $0x6,%10;" 680| 87.5k| "xor %9,%12;" 681| 87.5k| "pxor %%xmm3,%%xmm2;" 682| 87.5k| "ror $0x2,%11;" 683| 87.5k| "add %10,%12;" 684| 87.5k| "add 12+%16,%12;" 685| 87.5k| "pxor %%xmm2,%%xmm7;" 686| 87.5k| "mov %4,%10;" 687| 87.5k| "add %12,%3;" 688| 87.5k| "mov %4,%12;" 689| 87.5k| "pshufb %%xmm11,%%xmm7;" 690| 87.5k| "or %6,%10;" 691| 87.5k| "add %3,%k2;" 692| 87.5k| "and %6,%12;" 693| 87.5k| "paddd %%xmm0,%%xmm7;" 694| 87.5k| "and %5,%10;" 695| 87.5k| "add %11,%3;" 696| 87.5k| "or %12,%10;" 697| 87.5k| "add %10,%3;" 698| 87.5k| "sub $0x1,%1;" 699| 87.5k| "jne Lloop1_%=;" 700| 87.5k| "mov $0x2,%1;" 701| | 702| 87.5k| "Lloop2_%=:" 703| 87.5k| "paddd 0x0(%13),%%xmm4;" 704| 87.5k| "movdqa %%xmm4,%16;" 705| 87.5k| "mov %k2,%10;" 706| 87.5k| "ror $0xe,%10;" 707| 87.5k| "mov %3,%11;" 708| 87.5k| "xor %k2,%10;" 709| 87.5k| "ror $0x9,%11;" 710| 87.5k| "mov %7,%12;" 711| 87.5k| "xor %3,%11;" 712| 87.5k| "ror $0x5,%10;" 713| 87.5k| "xor %8,%12;" 714| 87.5k| "xor %k2,%10;" 715| 87.5k| "ror $0xb,%11;" 716| 87.5k| "and %k2,%12;" 717| 87.5k| "xor %3,%11;" 718| 87.5k| "ror $0x6,%10;" 719| 87.5k| "xor %8,%12;" 720| 87.5k| "add %10,%12;" 721| 87.5k| "ror $0x2,%11;" 722| 87.5k| "add %16,%12;" 723| 87.5k| "mov %3,%10;" 724| 87.5k| "add %12,%9;" 725| 87.5k| "mov %3,%12;" 726| 87.5k| "or %5,%10;" 727| 87.5k| "add %9,%6;" 728| 87.5k| "and %5,%12;" 729| 87.5k| "and %4,%10;" 730| 87.5k| "add %11,%9;" 731| 87.5k| "or %12,%10;" 732| 87.5k| "add %10,%9;" 733| 87.5k| "mov %6,%10;" 734| 87.5k| "ror $0xe,%10;" 735| 87.5k| "mov %9,%11;" 736| 87.5k| "xor %6,%10;" 737| 87.5k| "ror $0x9,%11;" 738| 87.5k| "mov %k2,%12;" 739| 87.5k| "xor %9,%11;" 740| 87.5k| "ror $0x5,%10;" 741| 87.5k| "xor %7,%12;" 742| 87.5k| "xor %6,%10;" 743| 87.5k| "ror $0xb,%11;" 744| 87.5k| "and %6,%12;" 745| 87.5k| "xor %9,%11;" 746| 87.5k| "ror $0x6,%10;" 747| 87.5k| "xor %7,%12;" 748| 87.5k| "add %10,%12;" 749| 87.5k| "ror $0x2,%11;" 750| 87.5k| "add 4+%16,%12;" 751| 87.5k| "mov %9,%10;" 752| 87.5k| "add %12,%8;" 753| 87.5k| "mov %9,%12;" 754| 87.5k| "or %4,%10;" 755| 87.5k| "add %8,%5;" 756| 87.5k| "and %4,%12;" 757| 87.5k| "and %3,%10;" 758| 87.5k| "add %11,%8;" 759| 87.5k| "or %12,%10;" 760| 87.5k| "add %10,%8;" 761| 87.5k| "mov %5,%10;" 762| 87.5k| "ror $0xe,%10;" 763| 87.5k| "mov %8,%11;" 764| 87.5k| "xor %5,%10;" 765| 87.5k| "ror $0x9,%11;" 766| 87.5k| "mov %6,%12;" 767| 87.5k| "xor %8,%11;" 768| 87.5k| "ror $0x5,%10;" 769| 87.5k| "xor %k2,%12;" 770| 87.5k| "xor %5,%10;" 771| 87.5k| "ror $0xb,%11;" 772| 87.5k| "and %5,%12;" 773| 87.5k| "xor %8,%11;" 774| 87.5k| "ror $0x6,%10;" 775| 87.5k| "xor %k2,%12;" 776| 87.5k| "add %10,%12;" 777| 87.5k| "ror $0x2,%11;" 778| 87.5k| "add 8+%16,%12;" 779| 87.5k| "mov %8,%10;" 780| 87.5k| "add %12,%7;" 781| 87.5k| "mov %8,%12;" 782| 87.5k| "or %3,%10;" 783| 87.5k| "add %7,%4;" 784| 87.5k| "and %3,%12;" 785| 87.5k| "and %9,%10;" 786| 87.5k| "add %11,%7;" 787| 87.5k| "or %12,%10;" 788| 87.5k| "add %10,%7;" 789| 87.5k| "mov %4,%10;" 790| 87.5k| "ror $0xe,%10;" 791| 87.5k| "mov %7,%11;" 792| 87.5k| "xor %4,%10;" 793| 87.5k| "ror $0x9,%11;" 794| 87.5k| "mov %5,%12;" 795| 87.5k| "xor %7,%11;" 796| 87.5k| "ror $0x5,%10;" 797| 87.5k| "xor %6,%12;" 798| 87.5k| "xor %4,%10;" 799| 87.5k| "ror $0xb,%11;" 800| 87.5k| "and %4,%12;" 801| 87.5k| "xor %7,%11;" 802| 87.5k| "ror $0x6,%10;" 803| 87.5k| "xor %6,%12;" 804| 87.5k| "add %10,%12;" 805| 87.5k| "ror $0x2,%11;" 806| 87.5k| "add 12+%16,%12;" 807| 87.5k| "mov %7,%10;" 808| 87.5k| "add %12,%k2;" 809| 87.5k| "mov %7,%12;" 810| 87.5k| "or %9,%10;" 811| 87.5k| "add %k2,%3;" 812| 87.5k| "and %9,%12;" 813| 87.5k| "and %8,%10;" 814| 87.5k| "add %11,%k2;" 815| 87.5k| "or %12,%10;" 816| 87.5k| "add %10,%k2;" 817| 87.5k| "paddd 0x10(%13),%%xmm5;" 818| 87.5k| "movdqa %%xmm5,%16;" 819| 87.5k| "add $0x20,%13;" 820| 87.5k| "mov %3,%10;" 821| 87.5k| "ror $0xe,%10;" 822| 87.5k| "mov %k2,%11;" 823| 87.5k| "xor %3,%10;" 824| 87.5k| "ror $0x9,%11;" 825| 87.5k| "mov %4,%12;" 826| 87.5k| "xor %k2,%11;" 827| 87.5k| "ror $0x5,%10;" 828| 87.5k| "xor %5,%12;" 829| 87.5k| "xor %3,%10;" 830| 87.5k| "ror $0xb,%11;" 831| 87.5k| "and %3,%12;" 832| 87.5k| "xor %k2,%11;" 833| 87.5k| "ror $0x6,%10;" 834| 87.5k| "xor %5,%12;" 835| 87.5k| "add %10,%12;" 836| 87.5k| "ror $0x2,%11;" 837| 87.5k| "add %16,%12;" 838| 87.5k| "mov %k2,%10;" 839| 87.5k| "add %12,%6;" 840| 87.5k| "mov %k2,%12;" 841| 87.5k| "or %8,%10;" 842| 87.5k| "add %6,%9;" 843| 87.5k| "and %8,%12;" 844| 87.5k| "and %7,%10;" 845| 87.5k| "add %11,%6;" 846| 87.5k| "or %12,%10;" 847| 87.5k| "add %10,%6;" 848| 87.5k| "mov %9,%10;" 849| 87.5k| "ror $0xe,%10;" 850| 87.5k| "mov %6,%11;" 851| 87.5k| "xor %9,%10;" 852| 87.5k| "ror $0x9,%11;" 853| 87.5k| "mov %3,%12;" 854| 87.5k| "xor %6,%11;" 855| 87.5k| "ror $0x5,%10;" 856| 87.5k| "xor %4,%12;" 857| 87.5k| "xor %9,%10;" 858| 87.5k| "ror $0xb,%11;" 859| 87.5k| "and %9,%12;" 860| 87.5k| "xor %6,%11;" 861| 87.5k| "ror $0x6,%10;" 862| 87.5k| "xor %4,%12;" 863| 87.5k| "add %10,%12;" 864| 87.5k| "ror $0x2,%11;" 865| 87.5k| "add 4+%16,%12;" 866| 87.5k| "mov %6,%10;" 867| 87.5k| "add %12,%5;" 868| 87.5k| "mov %6,%12;" 869| 87.5k| "or %7,%10;" 870| 87.5k| "add %5,%8;" 871| 87.5k| "and %7,%12;" 872| 87.5k| "and %k2,%10;" 873| 87.5k| "add %11,%5;" 874| 87.5k| "or %12,%10;" 875| 87.5k| "add %10,%5;" 876| 87.5k| "mov %8,%10;" 877| 87.5k| "ror $0xe,%10;" 878| 87.5k| "mov %5,%11;" 879| 87.5k| "xor %8,%10;" 880| 87.5k| "ror $0x9,%11;" 881| 87.5k| "mov %9,%12;" 882| 87.5k| "xor %5,%11;" 883| 87.5k| "ror $0x5,%10;" 884| 87.5k| "xor %3,%12;" 885| 87.5k| "xor %8,%10;" 886| 87.5k| "ror $0xb,%11;" 887| 87.5k| "and %8,%12;" 888| 87.5k| "xor %5,%11;" 889| 87.5k| "ror $0x6,%10;" 890| 87.5k| "xor %3,%12;" 891| 87.5k| "add %10,%12;" 892| 87.5k| "ror $0x2,%11;" 893| 87.5k| "add 8+%16,%12;" 894| 87.5k| "mov %5,%10;" 895| 87.5k| "add %12,%4;" 896| 87.5k| "mov %5,%12;" 897| 87.5k| "or %k2,%10;" 898| 87.5k| "add %4,%7;" 899| 87.5k| "and %k2,%12;" 900| 87.5k| "and %6,%10;" 901| 87.5k| "add %11,%4;" 902| 87.5k| "or %12,%10;" 903| 87.5k| "add %10,%4;" 904| 87.5k| "mov %7,%10;" 905| 87.5k| "ror $0xe,%10;" 906| 87.5k| "mov %4,%11;" 907| 87.5k| "xor %7,%10;" 908| 87.5k| "ror $0x9,%11;" 909| 87.5k| "mov %8,%12;" 910| 87.5k| "xor %4,%11;" 911| 87.5k| "ror $0x5,%10;" 912| 87.5k| "xor %9,%12;" 913| 87.5k| "xor %7,%10;" 914| 87.5k| "ror $0xb,%11;" 915| 87.5k| "and %7,%12;" 916| 87.5k| "xor %4,%11;" 917| 87.5k| "ror $0x6,%10;" 918| 87.5k| "xor %9,%12;" 919| 87.5k| "add %10,%12;" 920| 87.5k| "ror $0x2,%11;" 921| 87.5k| "add 12+%16,%12;" 922| 87.5k| "mov %4,%10;" 923| 87.5k| "add %12,%3;" 924| 87.5k| "mov %4,%12;" 925| 87.5k| "or %6,%10;" 926| 87.5k| "add %3,%k2;" 927| 87.5k| "and %6,%12;" 928| 87.5k| "and %5,%10;" 929| 87.5k| "add %11,%3;" 930| 87.5k| "or %12,%10;" 931| 87.5k| "add %10,%3;" 932| 87.5k| "movdqa %%xmm6,%%xmm4;" 933| 87.5k| "movdqa %%xmm7,%%xmm5;" 934| 87.5k| "sub $0x1,%1;" 935| 87.5k| "jne Lloop2_%=;" 936| 87.5k| "add (%0),%3;" 937| 87.5k| "mov %3,(%0);" 938| 87.5k| "add 0x4(%0),%4;" 939| 87.5k| "mov %4,0x4(%0);" 940| 87.5k| "add 0x8(%0),%5;" 941| 87.5k| "mov %5,0x8(%0);" 942| 87.5k| "add 0xc(%0),%6;" 943| 87.5k| "mov %6,0xc(%0);" 944| 87.5k| "add 0x10(%0),%k2;" 945| 87.5k| "mov %k2,0x10(%0);" 946| 87.5k| "add 0x14(%0),%7;" 947| 87.5k| "mov %7,0x14(%0);" 948| 87.5k| "add 0x18(%0),%8;" 949| 87.5k| "mov %8,0x18(%0);" 950| 87.5k| "add 0x1c(%0),%9;" 951| 87.5k| "mov %9,0x1c(%0);" 952| 87.5k| "mov %15,%1;" 953| 87.5k| "add $0x40,%1;" 954| 87.5k| "cmp %14,%1;" 955| 87.5k| "jne Lloop0_%=;" 956| | 957| 87.5k| "Ldone_hash_%=:" 958| | 959| 87.5k| : "+r"(s), "+r"(chunk), "+r"(blocks), "=r"(a), "=r"(b), "=r"(c), "=r"(d), /* e = chunk */ "=r"(f), "=r"(g), "=r"(h), "=r"(y0), "=r"(y1), "=r"(y2), "=r"(tbl), "+m"(inp_end), "+m"(inp), "+m"(xfer) 960| 87.5k| : "m"(K256), "m"(FLIP_MASK), "m"(SHUF_00BA), "m"(SHUF_DC00) 961| 87.5k| : "cc", "memory", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12" 962| 87.5k| ); 963| 87.5k|} _ZN10HashWriter5writeE4SpanIKSt4byteE: 107| 808k| { 108| 808k| ctx.Write(UCharCast(src.data()), src.size()); 109| 808k| } _ZN10HashWriter7GetHashEv: 115| 704| uint256 GetHash() { 116| 704| uint256 result; 117| 704| ctx.Finalize(result.begin()); 118| 704| ctx.Reset().Write(result.begin(), CSHA256::OUTPUT_SIZE).Finalize(result.begin()); 119| 704| return result; 120| 704| } _ZN10HashWriterlsI13ParamsWrapperI20TransactionSerParamsK12CTransactionEEERS_RKT_: 142| 704| { 143| 704| ::Serialize(*this, obj); 144| 704| return *this; 145| 704| } _ZN10interfaces5ChainD2Ev: 131| 2| virtual ~Chain() = default; _ZN11ECC_ContextD2Ev: 482| 2|{ 483| 2| ECC_Stop(); 484| 2|} key.cpp:_ZL8ECC_Stopv: 467| 2|static void ECC_Stop() { 468| 2| secp256k1_context *ctx = secp256k1_context_sign; 469| 2| secp256k1_context_sign = nullptr; 470| | 471| 2| if (ctx) { ------------------ | Branch (471:9): [True: 2, False: 0] ------------------ 472| 2| secp256k1_context_destroy(ctx); 473| 2| } 474| 2|} _Z11LogInstancev: 25| 2|{ 26| |/** 27| | * NOTE: the logger instances is leaked on exit. This is ugly, but will be 28| | * cleaned up by the OS/libc. Defining a logger as a global object doesn't work 29| | * since the order of destruction of static/global objects is undefined. 30| | * Consider if the logger gets destroyed, and then some later destructor calls 31| | * LogPrintf, maybe indirectly, and you get a core dump at shutdown trying to 32| | * access the logger. When the shutdown sequence is fully audited and tested, 33| | * explicit destruction of these objects can be implemented by changing this 34| | * from a raw pointer to a std::unique_ptr. 35| | * Since the ~Logger() destructor is never called, the Logger class and all 36| | * its subclasses must have implicitly-defined destructors. 37| | * 38| | * This method of initialization was originally introduced in 39| | * ee3374234c60aba2cc4c5cd5cac1c0aefc2d817c. 40| | */ 41| 2| static BCLog::Logger* g_logger{new BCLog::Logger()}; 42| 2| return *g_logger; 43| 2|} _ZN5BCLog6Logger20DisconnectTestLoggerEv: 97| 2|{ 98| 2| StdLockGuard scoped_lock(m_cs); 99| 2| m_buffering = true; 100| 2| if (m_fileout != nullptr) fclose(m_fileout); ------------------ | Branch (100:9): [True: 0, False: 2] ------------------ 101| 2| m_fileout = nullptr; 102| 2| m_print_callbacks.clear(); 103| 2| m_max_buffer_memusage = DEFAULT_MAX_LOG_BUFFER; 104| 2| m_cur_buffer_memusage = 0; 105| 2| m_buffer_lines_discarded = 0; 106| 2| m_msgs_before_open.clear(); 107| 2|} _ZN4node11NodeContextD2Ev: 26| 2|NodeContext::~NodeContext() = default; _ZN9prevectorILj28EhjiE8item_ptrEi: 206| 8.10k| T* item_ptr(difference_type pos) { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (206:47): [True: 3.02k, False: 5.08k] ------------------ _ZNK9prevectorILj28EhjiE9is_directEv: 173| 805k| bool is_direct() const { return _size <= N; } _ZN9prevectorILj28EhjiE10direct_ptrEi: 169| 8.10k| T* direct_ptr(difference_type pos) { return reinterpret_cast(_union.direct) + pos; } _ZN9prevectorILj28EhjiE12indirect_ptrEi: 171| 5.08k| T* indirect_ptr(difference_type pos) { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZNK9prevectorILj28EhjiE8capacityEv: 312| 8.10k| size_t capacity() const { 313| 8.10k| if (is_direct()) { ------------------ | Branch (313:13): [True: 8.10k, False: 0] ------------------ 314| 8.10k| return N; 315| 8.10k| } else { 316| 0| return _union.indirect_contents.capacity; 317| 0| } 318| 8.10k| } _ZN9prevectorILj28EhjiE15change_capacityEj: 175| 51.9k| void change_capacity(size_type new_capacity) { 176| 51.9k| if (new_capacity <= N) { ------------------ | Branch (176:13): [True: 46.8k, False: 5.08k] ------------------ 177| 46.8k| if (!is_direct()) { ------------------ | Branch (177:17): [True: 0, False: 46.8k] ------------------ 178| 0| T* indirect = indirect_ptr(0); 179| 0| T* src = indirect; 180| 0| T* dst = direct_ptr(0); 181| 0| memcpy(dst, src, size() * sizeof(T)); 182| 0| free(indirect); 183| 0| _size -= N + 1; 184| 0| } 185| 46.8k| } else { 186| 5.08k| if (!is_direct()) { ------------------ | Branch (186:17): [True: 0, False: 5.08k] ------------------ 187| | /* FIXME: Because malloc/realloc here won't call new_handler if allocation fails, assert 188| | success. These should instead use an allocator or new/delete so that handlers 189| | are called as necessary, but performance would be slightly degraded by doing so. */ 190| 0| _union.indirect_contents.indirect = static_cast(realloc(_union.indirect_contents.indirect, ((size_t)sizeof(T)) * new_capacity)); 191| 0| assert(_union.indirect_contents.indirect); 192| 0| _union.indirect_contents.capacity = new_capacity; 193| 5.08k| } else { 194| 5.08k| char* new_indirect = static_cast(malloc(((size_t)sizeof(T)) * new_capacity)); 195| 5.08k| assert(new_indirect); 196| 5.08k| T* src = direct_ptr(0); 197| 5.08k| T* dst = reinterpret_cast(new_indirect); 198| 5.08k| memcpy(dst, src, size() * sizeof(T)); 199| 5.08k| _union.indirect_contents.indirect = new_indirect; 200| 5.08k| _union.indirect_contents.capacity = new_capacity; 201| 5.08k| _size += N + 1; 202| 5.08k| } 203| 5.08k| } 204| 51.9k| } _ZNK9prevectorILj28EhjiE8item_ptrEi: 207| 19.0k| const T* item_ptr(difference_type pos) const { return is_direct() ? direct_ptr(pos) : indirect_ptr(pos); } ------------------ | Branch (207:59): [True: 7.22k, False: 11.8k] ------------------ _ZNK9prevectorILj28EhjiE10direct_ptrEi: 170| 7.22k| const T* direct_ptr(difference_type pos) const { return reinterpret_cast(_union.direct) + pos; } _ZNK9prevectorILj28EhjiE12indirect_ptrEi: 172| 11.8k| const T* indirect_ptr(difference_type pos) const { return reinterpret_cast(_union.indirect_contents.indirect) + pos; } _ZNK9prevectorILj28EhjiE4sizeEv: 294| 629k| size_type size() const { 295| 629k| return is_direct() ? _size : _size - N - 1; ------------------ | Branch (295:16): [True: 589k, False: 40.6k] ------------------ 296| 629k| } _ZN9prevectorILj28EhjiE5clearEv: 355| 135k| void clear() { 356| 135k| resize(0); 357| 135k| } _ZN9prevectorILj28EhjiE6resizeEj: 328| 135k| void resize(size_type new_size) { 329| 135k| size_type cur_size = size(); 330| 135k| if (cur_size == new_size) { ------------------ | Branch (330:13): [True: 135k, False: 0] ------------------ 331| 135k| return; 332| 135k| } 333| 0| if (cur_size > new_size) { ------------------ | Branch (333:13): [True: 0, False: 0] ------------------ 334| 0| erase(item_ptr(new_size), end()); 335| 0| return; 336| 0| } 337| 0| if (new_size > capacity()) { ------------------ | Branch (337:13): [True: 0, False: 0] ------------------ 338| 0| change_capacity(new_size); 339| 0| } 340| 0| ptrdiff_t increase = new_size - cur_size; 341| 0| fill(item_ptr(cur_size), increase); 342| 0| _size += increase; 343| 0| } _ZN9prevectorILj28EhjiE13shrink_to_fitEv: 351| 46.8k| void shrink_to_fit() { 352| 46.8k| change_capacity(size()); 353| 46.8k| } _ZNK9prevectorILj28EhjiE4dataEv: 537| 19.0k| const value_type* data() const { 538| 19.0k| return item_ptr(0); 539| 19.0k| } _ZNK9prevectorILj28EhjiE5emptyEv: 298| 206k| bool empty() const { 299| 206k| return size() == 0; 300| 206k| } _ZN9prevectorILj28EhjiED2Ev: 474| 88.4k| ~prevector() { 475| 88.4k| if (!is_direct()) { ------------------ | Branch (475:13): [True: 5.08k, False: 83.3k] ------------------ 476| 5.08k| free(_union.indirect_contents.indirect); 477| 5.08k| _union.indirect_contents.indirect = nullptr; 478| 5.08k| } 479| 88.4k| } _ZN9prevectorILj28EhjiEC2Ev: 243| 88.4k| prevector() = default; _ZN9prevectorILj28EhjiE20resize_uninitializedEj: 401| 8.10k| inline void resize_uninitialized(size_type new_size) { 402| | // resize_uninitialized changes the size of the prevector but does not initialize it. 403| | // If size < new_size, the added elements must be initialized explicitly. 404| 8.10k| if (capacity() < new_size) { ------------------ | Branch (404:13): [True: 5.08k, False: 3.02k] ------------------ 405| 5.08k| change_capacity(new_size); 406| 5.08k| _size += new_size - size(); 407| 5.08k| return; 408| 5.08k| } 409| 3.02k| if (new_size < size()) { ------------------ | Branch (409:13): [True: 0, False: 3.02k] ------------------ 410| 0| erase(item_ptr(new_size), end()); 411| 3.02k| } else { 412| 3.02k| _size += new_size - size(); 413| 3.02k| } 414| 3.02k| } _ZN9prevectorILj28EhjiEixEj: 320| 8.10k| T& operator[](size_type pos) { 321| 8.10k| return *item_ptr(pos); 322| 8.10k| } _ZNK12CTransaction17ComputeHasWitnessEv: 75| 477|{ 76| 477| return std::any_of(vin.begin(), vin.end(), [](const auto& input) { 77| 477| return !input.scriptWitness.IsNull(); 78| 477| }); 79| 477|} _ZNK12CTransaction11ComputeHashEv: 82| 477|{ 83| 477| return Txid::FromUint256((HashWriter{} << TX_NO_WITNESS(*this)).GetHash()); 84| 477|} _ZNK12CTransaction18ComputeWitnessHashEv: 87| 477|{ 88| 477| if (!HasWitness()) { ------------------ | Branch (88:9): [True: 250, False: 227] ------------------ 89| 250| return Wtxid::FromUint256(hash.ToUint256()); 90| 250| } 91| | 92| 227| return Wtxid::FromUint256((HashWriter{} << TX_WITH_WITNESS(*this)).GetHash()); 93| 477|} _ZN12CTransactionC2EO19CMutableTransaction: 96| 477|CTransaction::CTransaction(CMutableTransaction&& tx) : vin(std::move(tx.vin)), vout(std::move(tx.vout)), version{tx.version}, nLockTime{tx.nLockTime}, m_has_witness{ComputeHasWitness()}, hash{ComputeHash()}, m_witness_hash{ComputeWitnessHash()} {} transaction.cpp:_ZZNK12CTransaction17ComputeHasWitnessEvENK3$_0clI5CTxInEEDaRKT_: 76| 17.1k| return std::any_of(vin.begin(), vin.end(), [](const auto& input) { 77| 17.1k| return !input.scriptWitness.IsNull(); 78| 17.1k| }); _ZN9COutPointC2Ev: 36| 41.5k| COutPoint(): n(NULL_INDEX) { } _ZN5CTxInC2Ev: 122| 41.5k| { 123| 41.5k| nSequence = SEQUENCE_FINAL; 124| 41.5k| } _ZN6CTxOutC2Ev: 156| 46.8k| { 157| 46.8k| SetNull(); 158| 46.8k| } _ZN6CTxOut7SetNullEv: 165| 46.8k| { 166| 46.8k| nValue = -1; 167| 46.8k| scriptPubKey.clear(); 168| 46.8k| } _ZNK12CTransaction10HasWitnessEv: 373| 1.18k| bool HasWitness() const { return m_has_witness; } _ZNK19CMutableTransaction10HasWitnessEv: 413| 253| { 414| 14.8k| for (size_t i = 0; i < vin.size(); i++) { ------------------ | Branch (414:28): [True: 14.8k, False: 15] ------------------ 415| 14.8k| if (!vin[i].scriptWitness.IsNull()) { ------------------ | Branch (415:17): [True: 238, False: 14.6k] ------------------ 416| 238| return true; 417| 238| } 418| 14.8k| } 419| 15| return false; 420| 253| } _ZN12CTransactionC2I12ParamsStreamIR10DataStream20TransactionSerParamsEEE16deserialize_typeRT_: 337| 1.17k| CTransaction(deserialize_type, Stream& s) : CTransaction(CMutableTransaction(deserialize, s)) {} _ZN19CMutableTransactionC2I12ParamsStreamIR10DataStream20TransactionSerParamsEEE16deserialize_typeRT_: 403| 1.17k| CMutableTransaction(deserialize_type, Stream& s) { 404| 1.17k| Unserialize(s); 405| 1.17k| } _ZN19CMutableTransaction11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 393| 1.17k| inline void Unserialize(Stream& s) { 394| 1.17k| UnserializeTransaction(*this, s, s.template GetParams()); 395| 1.17k| } _Z22UnserializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE19CMutableTransactionEvRT0_RT_RKS3_: 217| 1.17k|{ 218| 1.17k| const bool fAllowWitness = params.allow_witness; 219| | 220| 1.17k| s >> tx.version; 221| 1.17k| unsigned char flags = 0; 222| 1.17k| tx.vin.clear(); 223| 1.17k| tx.vout.clear(); 224| | /* Try to read the vin. In case the dummy is there, this will be read as an empty vector. */ 225| 1.17k| s >> tx.vin; 226| 1.17k| if (tx.vin.size() == 0 && fAllowWitness) { ------------------ | Branch (226:9): [True: 675, False: 495] | Branch (226:31): [True: 675, False: 0] ------------------ 227| | /* We read a dummy or an empty vin. */ 228| 675| s >> flags; 229| 675| if (flags != 0) { ------------------ | Branch (229:13): [True: 642, False: 33] ------------------ 230| 642| s >> tx.vin; 231| 642| s >> tx.vout; 232| 642| } 233| 675| } else { 234| | /* We read a non-empty vin. Assume a normal vout follows. */ 235| 495| s >> tx.vout; 236| 495| } 237| 1.17k| if ((flags & 1) && fAllowWitness) { ------------------ | Branch (237:9): [True: 437, False: 733] | Branch (237:24): [True: 437, False: 0] ------------------ 238| | /* The witness flag is present, and we support witnesses. */ 239| 437| flags ^= 1; 240| 38.0k| for (size_t i = 0; i < tx.vin.size(); i++) { ------------------ | Branch (240:28): [True: 37.6k, False: 437] ------------------ 241| 37.6k| s >> tx.vin[i].scriptWitness.stack; 242| 37.6k| } 243| 437| if (!tx.HasWitness()) { ------------------ | Branch (243:13): [True: 15, False: 422] ------------------ 244| | /* It's illegal to encode witnesses when all witness stacks are empty. */ 245| 15| throw std::ios_base::failure("Superfluous witness record"); 246| 15| } 247| 437| } 248| 1.15k| if (flags) { ------------------ | Branch (248:9): [True: 12, False: 1.14k] ------------------ 249| | /* Unknown flag in the serialization */ 250| 12| throw std::ios_base::failure("Unknown transaction optional data"); 251| 12| } 252| 1.14k| s >> tx.nLockTime; 253| 1.14k|} _ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_: 129| 41.5k| SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); } ------------------ | | 156| 41.5k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_: 39| 41.5k| SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); } ------------------ | | 156| 41.5k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_: 162| 46.8k| SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); } ------------------ | | 156| 46.8k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZNK12CTransaction9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 328| 477| inline void Serialize(Stream& s) const { 329| 477| SerializeTransaction(*this, s, s.template GetParams()); 330| 477| } _Z20SerializeTransactionI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_: 257| 477|{ 258| 477| const bool fAllowWitness = params.allow_witness; 259| | 260| 477| s << tx.version; 261| 477| unsigned char flags = 0; 262| | // Consistency check 263| 477| if (fAllowWitness) { ------------------ | Branch (263:9): [True: 477, False: 0] ------------------ 264| | /* Check whether witnesses need to be serialized. */ 265| 477| if (tx.HasWitness()) { ------------------ | Branch (265:13): [True: 227, False: 250] ------------------ 266| 227| flags |= 1; 267| 227| } 268| 477| } 269| 477| if (flags) { ------------------ | Branch (269:9): [True: 227, False: 250] ------------------ 270| | /* Use extended format in case witnesses are to be serialized. */ 271| 227| std::vector vinDummy; 272| 227| s << vinDummy; 273| 227| s << flags; 274| 227| } 275| 477| s << tx.vin; 276| 477| s << tx.vout; 277| 477| if (flags & 1) { ------------------ | Branch (277:9): [True: 227, False: 250] ------------------ 278| 35.1k| for (size_t i = 0; i < tx.vin.size(); i++) { ------------------ | Branch (278:28): [True: 34.8k, False: 227] ------------------ 279| 34.8k| s << tx.vin[i].scriptWitness.stack; 280| 34.8k| } 281| 227| } 282| 477| s << tx.nLockTime; 283| 477|} _ZN5CTxIn16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 129| 38.0k| SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); } ------------------ | | 156| 38.0k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN9COutPoint16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 39| 38.0k| SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); } ------------------ | | 156| 38.0k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN6CTxOut16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 162| 45.7k| SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); } ------------------ | | 156| 45.7k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN5CTxIn16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 129| 72.9k| SERIALIZE_METHODS(CTxIn, obj) { READWRITE(obj.prevout, obj.scriptSig, obj.nSequence); } ------------------ | | 156| 72.9k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN9COutPoint16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 39| 72.9k| SERIALIZE_METHODS(COutPoint, obj) { READWRITE(obj.hash, obj.n); } ------------------ | | 156| 72.9k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN6CTxOut16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 162| 49.6k| SERIALIZE_METHODS(CTxOut, obj) { READWRITE(obj.nValue, obj.scriptPubKey); } ------------------ | | 156| 49.6k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZNK12CTransaction9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 328| 704| inline void Serialize(Stream& s) const { 329| 704| SerializeTransaction(*this, s, s.template GetParams()); 330| 704| } _Z20SerializeTransactionI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionEvRKT0_RT_RKS3_: 257| 704|{ 258| 704| const bool fAllowWitness = params.allow_witness; 259| | 260| 704| s << tx.version; 261| 704| unsigned char flags = 0; 262| | // Consistency check 263| 704| if (fAllowWitness) { ------------------ | Branch (263:9): [True: 227, False: 477] ------------------ 264| | /* Check whether witnesses need to be serialized. */ 265| 227| if (tx.HasWitness()) { ------------------ | Branch (265:13): [True: 227, False: 0] ------------------ 266| 227| flags |= 1; 267| 227| } 268| 227| } 269| 704| if (flags) { ------------------ | Branch (269:9): [True: 227, False: 477] ------------------ 270| | /* Use extended format in case witnesses are to be serialized. */ 271| 227| std::vector vinDummy; 272| 227| s << vinDummy; 273| 227| s << flags; 274| 227| } 275| 704| s << tx.vin; 276| 704| s << tx.vout; 277| 704| if (flags & 1) { ------------------ | Branch (277:9): [True: 227, False: 477] ------------------ 278| 35.1k| for (size_t i = 0; i < tx.vin.size(); i++) { ------------------ | Branch (278:28): [True: 34.8k, False: 227] ------------------ 279| 34.8k| s << tx.vin[i].scriptWitness.stack; 280| 34.8k| } 281| 227| } 282| 704| s << tx.nLockTime; 283| 704|} _ZN7CScript5clearEv: 577| 46.8k| { 578| | // The default prevector::clear() does not release memory 579| 46.8k| CScriptBase::clear(); 580| 46.8k| shrink_to_fit(); 581| 46.8k| } _ZNK14CScriptWitness6IsNullEv: 593| 31.9k| bool IsNull() const { return stack.empty(); } _ZN7CScriptC2Ev: 461| 88.4k| CScript() = default; _ZN14CScriptWitnessC2Ev: 591| 41.5k| CScriptWitness() = default; _ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsES_17ActionUnserializeEEvRT0_RT_T1_: 465| 88.2k| SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase(obj)); } ------------------ | | 156| 88.2k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN7CScript16SerializationOpsI12ParamsStreamIR10DataStream20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 465| 83.7k| SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase(obj)); } ------------------ | | 156| 83.7k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ _ZN7CScript16SerializationOpsI12ParamsStreamIR10HashWriter20TransactionSerParamsEKS_15ActionSerializeEEvRT0_RT_T1_: 465| 122k| SERIALIZE_METHODS(CScript, obj) { READWRITE(AsBase(obj)); } ------------------ | | 156| 122k|#define READWRITE(...) (ser_action.SerReadWriteMany(s, __VA_ARGS__)) ------------------ secp256k1.c:secp256k1_ecmult_gen_context_clear: 26| 2|static void secp256k1_ecmult_gen_context_clear(secp256k1_ecmult_gen_context *ctx) { 27| 2| ctx->built = 0; 28| 2| secp256k1_scalar_clear(&ctx->scalar_offset); 29| 2| secp256k1_ge_clear(&ctx->ge_offset); 30| 2| secp256k1_fe_clear(&ctx->proj_blind); 31| 2|} secp256k1.c:secp256k1_ecmult_gen_context_is_built: 22| 4|static int secp256k1_ecmult_gen_context_is_built(const secp256k1_ecmult_gen_context* ctx) { 23| 4| return ctx->built; 24| 4|} secp256k1.c:secp256k1_fe_clear: 21| 2|SECP256K1_INLINE static void secp256k1_fe_clear(secp256k1_fe *a) { 22| 2| secp256k1_memclear(a, sizeof(secp256k1_fe)); 23| 2|} secp256k1.c:secp256k1_ge_clear: 305| 2|static void secp256k1_ge_clear(secp256k1_ge *r) { 306| 2| secp256k1_memclear(r, sizeof(secp256k1_ge)); 307| 2|} secp256k1.c:secp256k1_scalar_clear: 30| 2|SECP256K1_INLINE static void secp256k1_scalar_clear(secp256k1_scalar *r) { 31| 2| secp256k1_memclear(r, sizeof(secp256k1_scalar)); 32| 2|} secp256k1_context_preallocated_destroy: 176| 2|void secp256k1_context_preallocated_destroy(secp256k1_context* ctx) { 177| 2| ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx)); ------------------ | | 52| 2|#define ARG_CHECK_VOID(cond) do { \ | | 53| 2| if (EXPECT(!(cond), 0)) { \ | | ------------------ | | | | 136| 4|#define EXPECT(x,c) __builtin_expect((x),(c)) | | | | ------------------ | | | | | Branch (136:21): [True: 0, False: 2] | | | | | Branch (136:39): [True: 0, False: 2] | | | | | Branch (136:39): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 54| 0| secp256k1_callback_call(&ctx->illegal_callback, #cond); \ | | 55| 0| return; \ | | 56| 0| } \ | | 57| 2|} while(0) | | ------------------ | | | Branch (57:9): [Folded - Ignored] | | ------------------ ------------------ 178| | 179| | /* Defined as noop */ 180| 2| if (ctx == NULL) { ------------------ | Branch (180:9): [True: 0, False: 2] ------------------ 181| 0| return; 182| 0| } 183| | 184| 2| secp256k1_ecmult_gen_context_clear(&ctx->ecmult_gen_ctx); 185| 2|} secp256k1_context_destroy: 187| 2|void secp256k1_context_destroy(secp256k1_context* ctx) { 188| 2| ARG_CHECK_VOID(ctx == NULL || secp256k1_context_is_proper(ctx)); ------------------ | | 52| 2|#define ARG_CHECK_VOID(cond) do { \ | | 53| 2| if (EXPECT(!(cond), 0)) { \ | | ------------------ | | | | 136| 4|#define EXPECT(x,c) __builtin_expect((x),(c)) | | | | ------------------ | | | | | Branch (136:21): [True: 0, False: 2] | | | | | Branch (136:39): [True: 0, False: 2] | | | | | Branch (136:39): [True: 2, False: 0] | | | | ------------------ | | ------------------ | | 54| 0| secp256k1_callback_call(&ctx->illegal_callback, #cond); \ | | 55| 0| return; \ | | 56| 0| } \ | | 57| 2|} while(0) | | ------------------ | | | Branch (57:9): [Folded - Ignored] | | ------------------ ------------------ 189| | 190| | /* Defined as noop */ 191| 2| if (ctx == NULL) { ------------------ | Branch (191:9): [True: 0, False: 2] ------------------ 192| 0| return; 193| 0| } 194| | 195| 2| secp256k1_context_preallocated_destroy(ctx); 196| 2| free(ctx); 197| 2|} secp256k1.c:secp256k1_context_is_proper: 82| 4|static int secp256k1_context_is_proper(const secp256k1_context* ctx) { 83| 4| return secp256k1_ecmult_gen_context_is_built(&ctx->ecmult_gen_ctx); 84| 4|} secp256k1.c:secp256k1_memclear: 223| 6|static SECP256K1_INLINE void secp256k1_memclear(void *ptr, size_t len) { 224| |#if defined(_MSC_VER) 225| | /* SecureZeroMemory is guaranteed not to be optimized out by MSVC. */ 226| | SecureZeroMemory(ptr, len); 227| |#elif defined(__GNUC__) 228| | /* We use a memory barrier that scares the compiler away from optimizing out the memset. 229| | * 230| | * Quoting Adam Langley in commit ad1907fe73334d6c696c8539646c21b11178f20f 231| | * in BoringSSL (ISC License): 232| | * As best as we can tell, this is sufficient to break any optimisations that 233| | * might try to eliminate "superfluous" memsets. 234| | * This method is used in memzero_explicit() the Linux kernel, too. Its advantage is that it 235| | * is pretty efficient, because the compiler can still implement the memset() efficently, 236| | * just not remove it entirely. See "Dead Store Elimination (Still) Considered Harmful" by 237| | * Yang et al. (USENIX Security 2017) for more background. 238| | */ 239| 6| memset(ptr, 0, len); 240| 6| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 241| |#else 242| | void *(*volatile const volatile_memset)(void *, int, size_t) = memset; 243| | volatile_memset(ptr, 0, len); 244| |#endif 245| |#ifdef VERIFY 246| | SECP256K1_CHECKMEM_UNDEFINE(ptr, len); 247| |#endif 248| 6|} _ZNK20TransactionSerParamsclIRK12CTransactionEEDaOT_: 1228| 704| { \ 1229| 704| return ParamsWrapper{*this, t}; \ 1230| 704| } _Z6AsBaseI9prevectorILj28EhjiE7CScriptERKT_RKT0_: 151| 206k|{ 152| 206k| static_assert(std::is_base_of_v); 153| 206k| return x; 154| 206k|} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ESA_: 481| 1.63k| explicit Wrapper(T obj) : m_object(obj) {} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ESA_: 481| 1.18k| explicit Wrapper(T obj) : m_object(obj) {} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESB_: 481| 69.7k| explicit Wrapper(T obj) : m_object(obj) {} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsEC2ES1_RKS2_: 1127| 1.64k| ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward(substream)} {} _Z14ser_readdata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEjRT_: 102| 84.8k|{ 103| 84.8k| uint32_t obj; 104| 84.8k| s.read(AsWritableBytes(Span{&obj, 1})); 105| 84.8k| return le32toh_internal(obj); 106| 84.8k|} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsE4readE4SpanISt4byteE: 1136| 5.96M| void read(Span dst) { GetStream().read(dst); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsE9GetStreamEv: 1154| 6.62M| { 1155| | if constexpr (ContainsStream) { 1156| | return m_substream.GetStream(); 1157| 6.62M| } else { 1158| 6.62M| return m_substream; 1159| 6.62M| } 1160| 6.62M| } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rj: 277| 84.4k|template inline void Unserialize(Stream& s, uint32_t& a) { a = ser_readdata32(s); } _Z15ReadCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_b: 340| 5.76M|{ 341| 5.76M| uint8_t chSize = ser_readdata8(is); 342| 5.76M| uint64_t nSizeRet = 0; 343| 5.76M| if (chSize < 253) ------------------ | Branch (343:9): [True: 5.75M, False: 1.55k] ------------------ 344| 5.75M| { 345| 5.75M| nSizeRet = chSize; 346| 5.75M| } 347| 1.55k| else if (chSize == 253) ------------------ | Branch (347:14): [True: 991, False: 560] ------------------ 348| 991| { 349| 991| nSizeRet = ser_readdata16(is); 350| 991| if (nSizeRet < 253) ------------------ | Branch (350:13): [True: 7, False: 984] ------------------ 351| 7| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 352| 991| } 353| 560| else if (chSize == 254) ------------------ | Branch (353:14): [True: 338, False: 222] ------------------ 354| 338| { 355| 338| nSizeRet = ser_readdata32(is); 356| 338| if (nSizeRet < 0x10000u) ------------------ | Branch (356:13): [True: 18, False: 320] ------------------ 357| 18| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 358| 338| } 359| 222| else 360| 222| { 361| 222| nSizeRet = ser_readdata64(is); 362| 222| if (nSizeRet < 0x100000000ULL) ------------------ | Branch (362:13): [True: 37, False: 185] ------------------ 363| 37| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 364| 222| } 365| 5.76M| if (range_check && nSizeRet > MAX_SIZE) { ------------------ | Branch (365:9): [True: 5.76M, False: 142] | Branch (365:24): [True: 61, False: 5.76M] ------------------ 366| 61| throw std::ios_base::failure("ReadCompactSize(): size too large"); 367| 61| } 368| 5.76M| return nSizeRet; 369| 5.76M|} _Z13ser_readdata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEhRT_: 84| 5.76M|{ 85| 5.76M| uint8_t obj; 86| 5.76M| s.read(AsWritableBytes(Span{&obj, 1})); 87| 5.76M| return obj; 88| 5.76M|} _Z14ser_readdata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEtRT_: 90| 991|{ 91| 991| uint16_t obj; 92| 991| s.read(AsWritableBytes(Span{&obj, 1})); 93| 991| return le16toh_internal(obj); 94| 991|} _Z14ser_readdata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEmRT_: 114| 46.9k|{ 115| 46.9k| uint64_t obj; 116| 46.9k| s.read(AsWritableBytes(Span{&obj, 1})); 117| 46.9k| return le64toh_internal(obj); 118| 46.9k|} _ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__110shared_ptrIK12CTransactionEEEEvRT_RT0_: 777| 1.17k| static void Unser(Stream& s, T& t) { Unserialize(s, t); } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionEvRT_RNSt3__110shared_ptrIKT0_EE: 985| 1.17k|{ 986| 1.17k| p = std::make_shared(deserialize, is); 987| 1.17k|} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRjEERS3_OT_: 1134| 1.65k| template ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_OT_: 1134| 1.78k| template ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE: 866| 1.78k|{ 867| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 868| | // Limit size per read so bogus size value won't cause out of memory 869| | v.clear(); 870| | unsigned int nSize = ReadCompactSize(is); 871| | unsigned int i = 0; 872| | while (i < nSize) { 873| | unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); 874| | v.resize(i + blk); 875| | is.read(AsWritableBytes(Span{&v[i], blk})); 876| | i += blk; 877| | } 878| 1.78k| } else { 879| 1.78k| Unserialize(is, Using>(v)); 880| 1.78k| } 881| 1.78k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_: 762| 1.78k|{ 763| 1.78k| a.Unserialize(is); 764| 1.78k|} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 483| 1.78k| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RT0_: 672| 1.78k| { 673| 1.78k| Formatter formatter; 674| 1.78k| v.clear(); 675| 1.78k| size_t size = ReadCompactSize(s); 676| 1.78k| size_t allocated = 0; 677| 2.55k| while (allocated < size) { ------------------ | Branch (677:16): [True: 773, False: 1.78k] ------------------ 678| | // For DoS prevention, do not blindly allocate as much as the stream claims to contain. 679| | // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide 680| | // X MiB of data to make us allocate X+5 Mib. 681| 773| static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large"); 682| 773| allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type)); 683| 773| v.reserve(allocated); 684| 42.2k| while (v.size() < allocated) { ------------------ | Branch (684:20): [True: 41.5k, False: 773] ------------------ 685| 41.5k| v.emplace_back(); 686| 41.5k| formatter.Unser(s, v.back()); 687| 41.5k| } 688| 773| } 689| 1.78k| }; _ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RT0_: 777| 41.5k| static void Unser(Stream& s, T& t) { Unserialize(s, t); } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER5CTxInQ14UnserializableIT0_T_EEvRS8_OS7_: 762| 41.5k|{ 763| 41.5k| a.Unserialize(is); 764| 41.5k|} _ZN5CTxIn11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 228| 41.5k| { \ 229| 41.5k| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 41.5k| Unser(s, *this); \ 231| 41.5k| } _ZN5CTxIn5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_: 180| 41.5k| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEEvRT_DpOT0_: 1033| 41.5k| { 1034| 41.5k| ::UnserializeMany(s, args...); 1035| 41.5k| } _Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9COutPointR7CScriptRjEEvRT_DpOT0_: 1001| 41.5k|{ 1002| 41.5k| (::Unserialize(s, args), ...); 1003| 41.5k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER9COutPointQ14UnserializableIT0_T_EEvRS8_OS7_: 762| 41.5k|{ 763| 41.5k| a.Unserialize(is); 764| 41.5k|} _ZN9COutPoint11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 228| 41.5k| { \ 229| 41.5k| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 41.5k| Unser(s, *this); \ 231| 41.5k| } _ZN9COutPoint5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_: 180| 41.5k| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEEvRT_DpOT0_: 1033| 41.5k| { 1034| 41.5k| ::UnserializeMany(s, args...); 1035| 41.5k| } _Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR22transaction_identifierILb0EERjEEvRT_DpOT0_: 1001| 41.5k|{ 1002| 41.5k| (::Unserialize(s, args), ...); 1003| 41.5k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER22transaction_identifierILb0EEQ14UnserializableIT0_T_EEvRS9_OS8_: 762| 41.5k|{ 763| 41.5k| a.Unserialize(is); 764| 41.5k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER7CScriptQ14UnserializableIT0_T_EEvRS8_OS7_: 762| 88.2k|{ 763| 88.2k| a.Unserialize(is); 764| 88.2k|} _ZN7CScript11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 228| 88.2k| { \ 229| 88.2k| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 88.2k| Unser(s, *this); \ 231| 88.2k| } _ZN7CScript5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_: 180| 88.2k| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEEvRT_DpOT0_: 1033| 88.2k| { 1034| 88.2k| ::UnserializeMany(s, args...); 1035| 88.2k| } _Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJR9prevectorILj28EhjiEEEvRT_DpOT0_: 1001| 88.2k|{ 1002| 88.2k| (::Unserialize(s, args), ...); 1003| 88.2k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj28EhEvRT_R9prevectorIXT0_ET1_jiE: 823| 88.2k|{ 824| 88.2k| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 825| | // Limit size per read so bogus size value won't cause out of memory 826| 88.2k| v.clear(); 827| 88.2k| unsigned int nSize = ReadCompactSize(is); 828| 88.2k| unsigned int i = 0; 829| 96.3k| while (i < nSize) { ------------------ | Branch (829:16): [True: 8.10k, False: 88.2k] ------------------ 830| 8.10k| unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); 831| 8.10k| v.resize_uninitialized(i + blk); 832| 8.10k| is.read(AsWritableBytes(Span{&v[i], blk})); 833| 8.10k| i += blk; 834| 8.10k| } 835| | } else { 836| | Unserialize(is, Using>(v)); 837| | } 838| 88.2k|} _Z6AsBaseI9prevectorILj28EhjiE7CScriptERT_RT0_: 145| 88.2k|{ 146| 88.2k| static_assert(std::is_base_of_v); 147| 88.2k| return x; 148| 88.2k|} block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_: 497| 1.78k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEEC2ES9_: 481| 1.78k| explicit Wrapper(T obj) : m_object(obj) {} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRhEERS3_OT_: 1134| 675| template ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rh: 273| 675|template inline void Unserialize(Stream& s, uint8_t& a ) { a = ser_readdata8(s); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_OT_: 1134| 853| template ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RNS6_6vectorIT0_T1_EE: 866| 853|{ 867| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 868| | // Limit size per read so bogus size value won't cause out of memory 869| | v.clear(); 870| | unsigned int nSize = ReadCompactSize(is); 871| | unsigned int i = 0; 872| | while (i < nSize) { 873| | unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); 874| | v.resize(i + blk); 875| | is.read(AsWritableBytes(Span{&v[i], blk})); 876| | i += blk; 877| | } 878| 853| } else { 879| 853| Unserialize(is, Using>(v)); 880| 853| } 881| 853|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ14UnserializableIT0_T_EEvRSI_OSH_: 762| 853|{ 763| 853| a.Unserialize(is); 764| 853|} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 483| 853| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RT0_: 672| 853| { 673| 853| Formatter formatter; 674| 853| v.clear(); 675| 853| size_t size = ReadCompactSize(s); 676| 853| size_t allocated = 0; 677| 1.24k| while (allocated < size) { ------------------ | Branch (677:16): [True: 387, False: 853] ------------------ 678| | // For DoS prevention, do not blindly allocate as much as the stream claims to contain. 679| | // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide 680| | // X MiB of data to make us allocate X+5 Mib. 681| 387| static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large"); 682| 387| allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type)); 683| 387| v.reserve(allocated); 684| 47.2k| while (v.size() < allocated) { ------------------ | Branch (684:20): [True: 46.8k, False: 387] ------------------ 685| 46.8k| v.emplace_back(); 686| 46.8k| formatter.Unser(s, v.back()); 687| 46.8k| } 688| 387| } 689| 853| }; _ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RT0_: 777| 46.8k| static void Unser(Stream& s, T& t) { Unserialize(s, t); } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER6CTxOutQ14UnserializableIT0_T_EEvRS8_OS7_: 762| 46.8k|{ 763| 46.8k| a.Unserialize(is); 764| 46.8k|} _ZN6CTxOut11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 228| 46.8k| { \ 229| 46.8k| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 46.8k| Unser(s, *this); \ 231| 46.8k| } _ZN6CTxOut5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RS_: 180| 46.8k| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEEvRT_DpOT0_: 1033| 46.8k| { 1034| 46.8k| ::UnserializeMany(s, args...); 1035| 46.8k| } _Z15UnserializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJRlR7CScriptEEvRT_DpOT0_: 1001| 46.8k|{ 1002| 46.8k| (::Unserialize(s, args), ...); 1003| 46.8k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_Rl: 278| 46.8k|template inline void Unserialize(Stream& s, int64_t& a ) { a = ser_readdata64(s); } block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSC_: 497| 853|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEEC2ES9_: 481| 853| explicit Wrapper(T obj) : m_object(obj) {} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsErsIRNSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_OT_: 1134| 37.6k| template ParamsStream& operator>>(U&& obj) { ::Unserialize(*this, obj); return *this; } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RNS6_IT0_T1_EE: 866| 37.6k|{ 867| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 868| | // Limit size per read so bogus size value won't cause out of memory 869| | v.clear(); 870| | unsigned int nSize = ReadCompactSize(is); 871| | unsigned int i = 0; 872| | while (i < nSize) { 873| | unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); 874| | v.resize(i + blk); 875| | is.read(AsWritableBytes(Span{&v[i], blk})); 876| | i += blk; 877| | } 878| 37.6k| } else { 879| 37.6k| Unserialize(is, Using>(v)); 880| 37.6k| } 881| 37.6k|} _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ14UnserializableIT0_T_EEvRSJ_OSI_: 762| 37.6k|{ 763| 37.6k| a.Unserialize(is); 764| 37.6k|} _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 483| 37.6k| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RT0_: 672| 37.6k| { 673| 37.6k| Formatter formatter; 674| 37.6k| v.clear(); 675| 37.6k| size_t size = ReadCompactSize(s); 676| 37.6k| size_t allocated = 0; 677| 38.8k| while (allocated < size) { ------------------ | Branch (677:16): [True: 1.22k, False: 37.6k] ------------------ 678| | // For DoS prevention, do not blindly allocate as much as the stream claims to contain. 679| | // Instead, allocate in 5MiB batches, so that an attacker actually needs to provide 680| | // X MiB of data to make us allocate X+5 Mib. 681| 1.22k| static_assert(sizeof(typename V::value_type) <= MAX_VECTOR_ALLOCATE, "Vector element size too large"); 682| 1.22k| allocated = std::min(size, allocated + MAX_VECTOR_ALLOCATE / sizeof(typename V::value_type)); 683| 1.22k| v.reserve(allocated); 684| 5.63M| while (v.size() < allocated) { ------------------ | Branch (684:20): [True: 5.63M, False: 1.22k] ------------------ 685| 5.63M| v.emplace_back(); 686| 5.63M| formatter.Unser(s, v.back()); 687| 5.63M| } 688| 1.22k| } 689| 37.6k| }; _ZN16DefaultFormatter5UnserI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RT0_: 777| 5.63M| static void Unser(Stream& s, T& t) { Unserialize(s, t); } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RNS5_6vectorIT0_T1_EE: 866| 5.63M|{ 867| 5.63M| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 868| | // Limit size per read so bogus size value won't cause out of memory 869| 5.63M| v.clear(); 870| 5.63M| unsigned int nSize = ReadCompactSize(is); 871| 5.63M| unsigned int i = 0; 872| 5.65M| while (i < nSize) { ------------------ | Branch (872:16): [True: 21.3k, False: 5.63M] ------------------ 873| 21.3k| unsigned int blk = std::min(nSize - i, (unsigned int)(1 + 4999999 / sizeof(T))); 874| 21.3k| v.resize(i + blk); 875| 21.3k| is.read(AsWritableBytes(Span{&v[i], blk})); 876| 21.3k| i += blk; 877| 21.3k| } 878| | } else { 879| | Unserialize(is, Using>(v)); 880| | } 881| 5.63M|} block.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSD_: 497| 37.6k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI15VectorFormatterI16DefaultFormatterERNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEEC2ESA_: 481| 37.6k| explicit Wrapper(T obj) : m_object(obj) {} _ZNK12ParamsStreamIR10DataStream20TransactionSerParamsE9GetParamsIS2_EERKDav: 1144| 1.64k| { 1145| 1.64k| if constexpr (std::is_convertible_v) { 1146| 1.64k| return m_params; 1147| | } else { 1148| | return m_substream.template GetParams

(); 1149| | } 1150| 1.64k| } _Z14ser_readdata32I10DataStreamEjRT_: 102| 63|{ 103| 63| uint32_t obj; 104| 63| s.read(AsWritableBytes(Span{&obj, 1})); 105| 63| return le32toh_internal(obj); 106| 63|} _Z15ReadCompactSizeI10DataStreamEmRT_b: 340| 1.32k|{ 341| 1.32k| uint8_t chSize = ser_readdata8(is); 342| 1.32k| uint64_t nSizeRet = 0; 343| 1.32k| if (chSize < 253) ------------------ | Branch (343:9): [True: 1.08k, False: 240] ------------------ 344| 1.08k| { 345| 1.08k| nSizeRet = chSize; 346| 1.08k| } 347| 240| else if (chSize == 253) ------------------ | Branch (347:14): [True: 91, False: 149] ------------------ 348| 91| { 349| 91| nSizeRet = ser_readdata16(is); 350| 91| if (nSizeRet < 253) ------------------ | Branch (350:13): [True: 8, False: 83] ------------------ 351| 8| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 352| 91| } 353| 149| else if (chSize == 254) ------------------ | Branch (353:14): [True: 63, False: 86] ------------------ 354| 63| { 355| 63| nSizeRet = ser_readdata32(is); 356| 63| if (nSizeRet < 0x10000u) ------------------ | Branch (356:13): [True: 16, False: 47] ------------------ 357| 16| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 358| 63| } 359| 86| else 360| 86| { 361| 86| nSizeRet = ser_readdata64(is); 362| 86| if (nSizeRet < 0x100000000ULL) ------------------ | Branch (362:13): [True: 34, False: 52] ------------------ 363| 34| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 364| 86| } 365| 1.27k| if (range_check && nSizeRet > MAX_SIZE) { ------------------ | Branch (365:9): [True: 1.26k, False: 5] | Branch (365:24): [True: 66, False: 1.20k] ------------------ 366| 66| throw std::ios_base::failure("ReadCompactSize(): size too large"); 367| 66| } 368| 1.20k| return nSizeRet; 369| 1.27k|} _Z13ser_readdata8I10DataStreamEhRT_: 84| 1.32k|{ 85| 1.32k| uint8_t obj; 86| 1.32k| s.read(AsWritableBytes(Span{&obj, 1})); 87| 1.32k| return obj; 88| 1.32k|} _Z14ser_readdata16I10DataStreamEtRT_: 90| 91|{ 91| 91| uint16_t obj; 92| 91| s.read(AsWritableBytes(Span{&obj, 1})); 93| 91| return le16toh_internal(obj); 94| 91|} _Z14ser_readdata64I10DataStreamEmRT_: 114| 86|{ 115| 86| uint64_t obj; 116| 86| s.read(AsWritableBytes(Span{&obj, 1})); 117| 86| return le64toh_internal(obj); 118| 86|} _Z14ser_writedata8I10DataStreamEvRT_h: 55| 477|{ 56| 477| s.write(AsBytes(Span{&obj, 1})); 57| 477|} _Z16WriteCompactSizeI10DataStreamEvRT_m: 309| 477|{ 310| 477| if (nSize < 253) ------------------ | Branch (310:9): [True: 423, False: 54] ------------------ 311| 423| { 312| 423| ser_writedata8(os, nSize); 313| 423| } 314| 54| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (314:14): [True: 54, False: 0] ------------------ 315| 54| { 316| 54| ser_writedata8(os, 253); 317| 54| ser_writedata16(os, nSize); 318| 54| } 319| 0| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (319:14): [True: 0, False: 0] ------------------ 320| 0| { 321| 0| ser_writedata8(os, 254); 322| 0| ser_writedata32(os, nSize); 323| 0| } 324| 0| else 325| 0| { 326| 0| ser_writedata8(os, 255); 327| 0| ser_writedata64(os, nSize); 328| 0| } 329| 477| return; 330| 477|} _Z15ser_writedata16I10DataStreamEvRT_t: 59| 54|{ 60| 54| obj = htole16_internal(obj); 61| 54| s.write(AsBytes(Span{&obj, 1})); 62| 54|} _Z11UnserializeI10DataStreamR20PrefilledTransactionQ14UnserializableIT0_T_EEvRS4_OS3_: 762| 1.32k|{ 763| 1.32k| a.Unserialize(is); 764| 1.32k|} _ZN20PrefilledTransaction11UnserializeI10DataStreamEEvRT_: 228| 1.32k| { \ 229| 1.32k| static_assert(std::is_same::value, "Unserialize type mismatch"); \ 230| 1.32k| Unser(s, *this); \ 231| 1.32k| } _ZN20PrefilledTransaction5UnserI10DataStreamEEvRT_RS_: 180| 1.32k| static void Unser(Stream& s, cls& obj) { SerializationOps(obj, s, ActionUnserialize{}); } \ _ZN17ActionUnserialize16SerReadWriteManyI10DataStreamJ7WrapperI20CompactSizeFormatterILb1EERtE13ParamsWrapperI20TransactionSerParamsS2_I16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEEEEEvRT_DpOT0_: 1033| 1.32k| { 1034| 1.32k| ::UnserializeMany(s, args...); 1035| 1.32k| } _Z15UnserializeManyI10DataStreamJR7WrapperI20CompactSizeFormatterILb1EERtER13ParamsWrapperI20TransactionSerParamsS1_I16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEEEEvRT_DpOT0_: 1001| 1.32k|{ 1002| 1.32k| (::Unserialize(s, args), ...); 1003| 1.32k|} _Z11UnserializeI10DataStreamR7WrapperI20CompactSizeFormatterILb1EERtEQ14UnserializableIT0_T_EEvRS8_OS7_: 762| 1.32k|{ 763| 1.32k| a.Unserialize(is); 764| 1.32k|} _ZN7WrapperI20CompactSizeFormatterILb1EERtE11UnserializeI10DataStreamEEvRT_: 483| 1.32k| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } _ZN20CompactSizeFormatterILb1EE5UnserI10DataStreamtEEvRT_RT0_: 569| 1.32k| { 570| 1.32k| uint64_t n = ReadCompactSize(s, RangeCheck); 571| 1.32k| if (n < std::numeric_limits::min() || n > std::numeric_limits::max()) { ------------------ | Branch (571:13): [True: 129, False: 1.20k] | Branch (571:50): [True: 30, False: 1.17k] ------------------ 572| 30| throw std::ios_base::failure("CompactSize exceeds limit of type"); 573| 30| } 574| 1.29k| v = n; 575| 1.29k| } _Z11UnserializeI10DataStreamR13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEEQ14UnserializableIT0_T_EEvRSF_OSE_: 762| 1.17k|{ 763| 1.17k| a.Unserialize(is); 764| 1.17k|} _ZN13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEE11UnserializeI10DataStreamEEvRT_: 1205| 1.17k| { 1206| 1.17k| ParamsStream ss{s, m_params}; 1207| 1.17k| ::Unserialize(ss, m_object); 1208| 1.17k| } _Z11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsER7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEQ14UnserializableIT0_T_EEvRSG_OSF_: 762| 1.17k|{ 763| 1.17k| a.Unserialize(is); 764| 1.17k|} _ZN7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 483| 1.17k| template void Unserialize(Stream &s) { Formatter().Unser(s, m_object); } deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERtE7WrapperIT_RT0_EOS5_: 497| 1.32k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI20CompactSizeFormatterILb1EERtEC2ES2_: 481| 1.32k| explicit Wrapper(T obj) : m_object(obj) {} _ZNK20TransactionSerParamsclI7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEEEDaOT_: 1228| 1.32k| { \ 1229| 1.32k| return ParamsWrapper{*this, t}; \ 1230| 1.32k| } _ZN13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEEC2ERKS0_RS9_: 1195| 1.32k| explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {} deserialize.cpp:_ZL5UsingI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEE7WrapperIT_RT0_EOS9_: 497| 1.32k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI16DefaultFormatterRNSt3__110shared_ptrIK12CTransactionEEEC2ES6_: 481| 1.32k| explicit Wrapper(T obj) : m_object(obj) {} _Z9SerializeI10DataStream20PrefilledTransactionQ12SerializableIT0_T_EEvRS3_RKS2_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZNK20PrefilledTransaction9SerializeI10DataStreamEEvRT_: 222| 477| { \ 223| 477| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 477| Ser(s, *this); \ 225| 477| } \ _ZN20PrefilledTransaction3SerI10DataStreamEEvRT_RKS_: 178| 477| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI10DataStreamJ7WrapperI20CompactSizeFormatterILb1EERKtE13ParamsWrapperI20TransactionSerParamsS2_I16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEEEEEvRT_DpRKT0_: 1013| 477| { 1014| 477| ::SerializeMany(s, args...); 1015| 477| } _Z13SerializeManyI10DataStreamJ7WrapperI20CompactSizeFormatterILb1EERKtE13ParamsWrapperI20TransactionSerParamsS1_I16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEEEEvRT_DpRKT0_: 995| 477|{ 996| 477| (::Serialize(s, args), ...); 997| 477|} _Z9SerializeI10DataStream7WrapperI20CompactSizeFormatterILb1EERKtEQ12SerializableIT0_T_EEvRS8_RKS7_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZNK7WrapperI20CompactSizeFormatterILb1EERKtE9SerializeI10DataStreamEEvRT_: 482| 477| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN20CompactSizeFormatterILb1EE3SerI10DataStreamtEEvRT_T0_: 579| 477| { 580| 477| static_assert(std::is_unsigned::value, "CompactSize only supported for unsigned integers"); 581| 477| static_assert(std::numeric_limits::max() <= std::numeric_limits::max(), "CompactSize only supports 64-bit integers and below"); 582| | 583| 477| WriteCompactSize(s, v); 584| 477| } _Z9SerializeI10DataStream13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEEQ12SerializableIT0_T_EEvRSF_RKSE_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZNK13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEE9SerializeI10DataStreamEEvRT_: 1199| 477| { 1200| 477| ParamsStream ss{s, m_params}; 1201| 477| ::Serialize(ss, m_object); 1202| 477| } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEQ12SerializableIT0_T_EEvRSG_RKSF_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZNK7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 482| 477| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__110shared_ptrIK12CTransactionEEEEvRT_RKT0_: 774| 477| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionEvRT_RKNSt3__110shared_ptrIKT0_EE: 979| 477|{ 980| 477| Serialize(os, *p); 981| 477|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIjEERS3_RKT_: 1133| 954| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j: 262| 76.9k|template inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); } _Z15ser_writedata32I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_j: 69| 77.0k|{ 70| 77.0k| obj = htole32_internal(obj); 71| 77.0k| s.write(AsBytes(Span{&obj, 1})); 72| 77.0k|} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsE5writeE4SpanIKSt4byteE: 1135| 655k| void write(Span src) { GetStream().write(src); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_: 1133| 704| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE: 846| 704|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 704| } else { 859| 704| Serialize(os, Using>(v)); 860| 704| } 861| 704|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_: 753| 704|{ 754| 704| a.Serialize(os); 755| 704|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 482| 704| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_: 662| 704| { 663| 704| Formatter formatter; 664| 704| WriteCompactSize(s, v.size()); 665| 38.0k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 38.0k, False: 704] ------------------ 666| 38.0k| formatter.Ser(s, elem); 667| 38.0k| } 668| 704| } _Z16WriteCompactSizeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m: 309| 466k|{ 310| 466k| if (nSize < 253) ------------------ | Branch (310:9): [True: 466k, False: 637] ------------------ 311| 466k| { 312| 466k| ser_writedata8(os, nSize); 313| 466k| } 314| 637| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (314:14): [True: 547, False: 90] ------------------ 315| 547| { 316| 547| ser_writedata8(os, 253); 317| 547| ser_writedata16(os, nSize); 318| 547| } 319| 90| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (319:14): [True: 90, False: 0] ------------------ 320| 90| { 321| 90| ser_writedata8(os, 254); 322| 90| ser_writedata32(os, nSize); 323| 90| } 324| 0| else 325| 0| { 326| 0| ser_writedata8(os, 255); 327| 0| ser_writedata64(os, nSize); 328| 0| } 329| 466k| return; 330| 466k|} _Z14ser_writedata8I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h: 55| 467k|{ 56| 467k| s.write(AsBytes(Span{&obj, 1})); 57| 467k|} _Z15ser_writedata16I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_t: 59| 547|{ 60| 547| obj = htole16_internal(obj); 61| 547| s.write(AsBytes(Span{&obj, 1})); 62| 547|} _Z15ser_writedata64I12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_m: 79| 45.7k|{ 80| 45.7k| obj = htole64_internal(obj); 81| 45.7k| s.write(AsBytes(Span{&obj, 1})); 82| 45.7k|} _ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInEEvRT_RKT0_: 774| 38.0k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 38.0k|{ 754| 38.0k| a.Serialize(os); 755| 38.0k|} _ZNK5CTxIn9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 222| 38.0k| { \ 223| 38.0k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 38.0k| Ser(s, *this); \ 225| 38.0k| } \ _ZN5CTxIn3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_: 178| 38.0k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_: 1013| 38.0k| { 1014| 38.0k| ::SerializeMany(s, args...); 1015| 38.0k| } _Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_: 995| 38.0k|{ 996| 38.0k| (::Serialize(s, args), ...); 997| 38.0k|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 38.0k|{ 754| 38.0k| a.Serialize(os); 755| 38.0k|} _ZNK9COutPoint9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 222| 38.0k| { \ 223| 38.0k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 38.0k| Ser(s, *this); \ 225| 38.0k| } \ _ZN9COutPoint3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_: 178| 38.0k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_: 1013| 38.0k| { 1014| 38.0k| ::SerializeMany(s, args...); 1015| 38.0k| } _Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_: 995| 38.0k|{ 996| 38.0k| (::Serialize(s, args), ...); 997| 38.0k|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_: 753| 38.0k|{ 754| 38.0k| a.Serialize(os); 755| 38.0k|} _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_: 1133| 38.0k| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E: 268| 38.0k|template void Serialize(Stream& s, Span span) { s.write(AsBytes(span)); } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 83.7k|{ 754| 83.7k| a.Serialize(os); 755| 83.7k|} _ZNK7CScript9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 222| 83.7k| { \ 223| 83.7k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 83.7k| Ser(s, *this); \ 225| 83.7k| } \ _ZN7CScript3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_: 178| 83.7k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_: 1013| 83.7k| { 1014| 83.7k| ::SerializeMany(s, args...); 1015| 83.7k| } _Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_: 995| 83.7k|{ 996| 83.7k| (::Serialize(s, args), ...); 997| 83.7k|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE: 811| 83.7k|{ 812| 83.7k| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 813| 83.7k| WriteCompactSize(os, v.size()); 814| 83.7k| if (!v.empty()) os.write(MakeByteSpan(v)); ------------------ | Branch (814:13): [True: 7.23k, False: 76.5k] ------------------ 815| | } else { 816| | Serialize(os, Using>(v)); 817| | } 818| 83.7k|} deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_: 497| 704|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsIhEERS3_RKT_: 1133| 227| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_h: 258| 227|template inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_: 1133| 477| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE: 846| 477|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 477| } else { 859| 477| Serialize(os, Using>(v)); 860| 477| } 861| 477|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_: 753| 477|{ 754| 477| a.Serialize(os); 755| 477|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 482| 477| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_: 662| 477| { 663| 477| Formatter formatter; 664| 477| WriteCompactSize(s, v.size()); 665| 45.7k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 45.7k, False: 477] ------------------ 666| 45.7k| formatter.Ser(s, elem); 667| 45.7k| } 668| 477| } _ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutEEvRT_RKT0_: 774| 45.7k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 45.7k|{ 754| 45.7k| a.Serialize(os); 755| 45.7k|} _ZNK6CTxOut9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 222| 45.7k| { \ 223| 45.7k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 45.7k| Ser(s, *this); \ 225| 45.7k| } \ _ZN6CTxOut3SerI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_RKS_: 178| 45.7k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_: 1013| 45.7k| { 1014| 45.7k| ::SerializeMany(s, args...); 1015| 45.7k| } _Z13SerializeManyI12ParamsStreamIR10DataStream20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_: 995| 45.7k|{ 996| 45.7k| (::Serialize(s, args), ...); 997| 45.7k|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEvRT_l: 263| 45.7k|template inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); } deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_: 497| 477|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN12ParamsStreamIR10DataStream20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_: 1133| 34.8k| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE: 846| 34.8k|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 34.8k| } else { 859| 34.8k| Serialize(os, Using>(v)); 860| 34.8k| } 861| 34.8k|} _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_: 753| 34.8k|{ 754| 34.8k| a.Serialize(os); 755| 34.8k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 482| 34.8k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_: 662| 34.8k| { 663| 34.8k| Formatter formatter; 664| 34.8k| WriteCompactSize(s, v.size()); 665| 346k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 346k, False: 34.8k] ------------------ 666| 346k| formatter.Ser(s, elem); 667| 346k| } 668| 34.8k| } _ZN16DefaultFormatter3SerI12ParamsStreamIR10DataStream20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_: 774| 346k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE: 846| 346k|{ 847| 346k| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| 346k| WriteCompactSize(os, v.size()); 849| 346k| if (!v.empty()) os.write(MakeByteSpan(v)); ------------------ | Branch (849:13): [True: 19.8k, False: 327k] ------------------ 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| | } else { 859| | Serialize(os, Using>(v)); 860| | } 861| 346k|} deserialize.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_: 497| 34.8k|static inline Wrapper Using(T&& t) { return Wrapper(t); } deserialize.cpp:_ZL5UsingI20CompactSizeFormatterILb1EERKtE7WrapperIT_RT0_EOS6_: 497| 477|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI20CompactSizeFormatterILb1EERKtEC2ES3_: 481| 477| explicit Wrapper(T obj) : m_object(obj) {} _ZNK20TransactionSerParamsclI7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEEEDaOT_: 1228| 477| { \ 1229| 477| return ParamsWrapper{*this, t}; \ 1230| 477| } _ZN13ParamsWrapperI20TransactionSerParams7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEEC2ERKS0_RSA_: 1195| 477| explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {} deserialize.cpp:_ZL5UsingI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEE7WrapperIT_RT0_EOSA_: 497| 477|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN7WrapperI16DefaultFormatterRKNSt3__110shared_ptrIK12CTransactionEEEC2ES7_: 481| 477| explicit Wrapper(T obj) : m_object(obj) {} transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_: 497| 931|static inline Wrapper Using(T&& t) { return Wrapper(t); } transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE7WrapperIT_RT0_EOSD_: 497| 704|static inline Wrapper Using(T&& t) { return Wrapper(t); } transaction.cpp:_ZL5UsingI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE7WrapperIT_RT0_EOSE_: 497| 34.8k|static inline Wrapper Using(T&& t) { return Wrapper(t); } _ZN13ParamsWrapperI20TransactionSerParamsK12CTransactionEC2ERKS0_RS2_: 1195| 704| explicit ParamsWrapper(const Params& params, T& obj) : m_params{params}, m_object{obj} {} _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsEC2ES1_RKS2_: 1127| 704| ParamsStream(SubStream&& substream, const Params& params LIFETIMEBOUND) : m_params{params}, m_substream{std::forward(substream)} {} _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIjEERS3_RKT_: 1133| 1.40k| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j: 262| 147k|template inline void Serialize(Stream& s, uint32_t a) { ser_writedata32(s, a); } _Z15ser_writedata32I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_j: 69| 147k|{ 70| 147k| obj = htole32_internal(obj); 71| 147k| s.write(AsBytes(Span{&obj, 1})); 72| 147k|} _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE5writeE4SpanIKSt4byteE: 1135| 808k| void write(Span src) { GetStream().write(src); } _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetStreamEv: 1154| 808k| { 1155| | if constexpr (ContainsStream) { 1156| | return m_substream.GetStream(); 1157| 808k| } else { 1158| 808k| return m_substream; 1159| 808k| } 1160| 808k| } _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI5CTxInNS5_9allocatorIS7_EEEEEERS3_RKT_: 1133| 931| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE: 846| 931|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 931| } else { 859| 931| Serialize(os, Using>(v)); 860| 931| } 861| 931|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_: 753| 931|{ 754| 931| a.Serialize(os); 755| 931|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI5CTxInNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 482| 931| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI5CTxInNS8_9allocatorISA_EEEEEEvRT_RKT0_: 662| 931| { 663| 931| Formatter formatter; 664| 931| WriteCompactSize(s, v.size()); 665| 72.9k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 72.9k, False: 931] ------------------ 666| 72.9k| formatter.Ser(s, elem); 667| 72.9k| } 668| 931| } _Z16WriteCompactSizeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m: 309| 506k|{ 310| 506k| if (nSize < 253) ------------------ | Branch (310:9): [True: 505k, False: 713] ------------------ 311| 505k| { 312| 505k| ser_writedata8(os, nSize); 313| 505k| } 314| 713| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (314:14): [True: 592, False: 121] ------------------ 315| 592| { 316| 592| ser_writedata8(os, 253); 317| 592| ser_writedata16(os, nSize); 318| 592| } 319| 121| else if (nSize <= std::numeric_limits::max()) ------------------ | Branch (319:14): [True: 121, False: 0] ------------------ 320| 121| { 321| 121| ser_writedata8(os, 254); 322| 121| ser_writedata32(os, nSize); 323| 121| } 324| 0| else 325| 0| { 326| 0| ser_writedata8(os, 255); 327| 0| ser_writedata64(os, nSize); 328| 0| } 329| 506k| return; 330| 506k|} _Z14ser_writedata8I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h: 55| 506k|{ 56| 506k| s.write(AsBytes(Span{&obj, 1})); 57| 506k|} _Z15ser_writedata16I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_t: 59| 592|{ 60| 592| obj = htole16_internal(obj); 61| 592| s.write(AsBytes(Span{&obj, 1})); 62| 592|} _Z15ser_writedata64I12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_m: 79| 49.6k|{ 80| 49.6k| obj = htole64_internal(obj); 81| 49.6k| s.write(AsBytes(Span{&obj, 1})); 82| 49.6k|} _ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInEEvRT_RKT0_: 774| 72.9k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE5CTxInQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 72.9k|{ 754| 72.9k| a.Serialize(os); 755| 72.9k|} _ZNK5CTxIn9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 222| 72.9k| { \ 223| 72.9k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 72.9k| Ser(s, *this); \ 225| 72.9k| } \ _ZN5CTxIn3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_: 178| 72.9k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEEvRT_DpRKT0_: 1013| 72.9k| { 1014| 72.9k| ::SerializeMany(s, args...); 1015| 72.9k| } _Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9COutPoint7CScriptjEEvRT_DpRKT0_: 995| 72.9k|{ 996| 72.9k| (::Serialize(s, args), ...); 997| 72.9k|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE9COutPointQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 72.9k|{ 754| 72.9k| a.Serialize(os); 755| 72.9k|} _ZNK9COutPoint9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 222| 72.9k| { \ 223| 72.9k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 72.9k| Ser(s, *this); \ 225| 72.9k| } \ _ZN9COutPoint3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_: 178| 72.9k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEEvRT_DpRKT0_: 1013| 72.9k| { 1014| 72.9k| ::SerializeMany(s, args...); 1015| 72.9k| } _Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ22transaction_identifierILb0EEjEEvRT_DpRKT0_: 995| 72.9k|{ 996| 72.9k| (::Serialize(s, args), ...); 997| 72.9k|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE22transaction_identifierILb0EEQ12SerializableIT0_T_EEvRS8_RKS7_: 753| 72.9k|{ 754| 72.9k| a.Serialize(os); 755| 72.9k|} _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsI4SpanIKhEEERS3_RKT_: 1133| 72.9k| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsETk9BasicByteKhEvRT_4SpanIT0_E: 268| 72.9k|template void Serialize(Stream& s, Span span) { s.write(AsBytes(span)); } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7CScriptQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 122k|{ 754| 122k| a.Serialize(os); 755| 122k|} _ZNK7CScript9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 222| 122k| { \ 223| 122k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 122k| Ser(s, *this); \ 225| 122k| } \ _ZN7CScript3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_: 178| 122k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEEvRT_DpRKT0_: 1013| 122k| { 1014| 122k| ::SerializeMany(s, args...); 1015| 122k| } _Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJ9prevectorILj28EhjiEEEvRT_DpRKT0_: 995| 122k|{ 996| 122k| (::Serialize(s, args), ...); 997| 122k|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsELj28EhEvRT_RK9prevectorIXT0_ET1_jiE: 811| 122k|{ 812| 122k| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 813| 122k| WriteCompactSize(os, v.size()); 814| 122k| if (!v.empty()) os.write(MakeByteSpan(v)); ------------------ | Branch (814:13): [True: 11.8k, False: 110k] ------------------ 815| | } else { 816| | Serialize(os, Using>(v)); 817| | } 818| 122k|} _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsIhEERS3_RKT_: 1133| 227| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_h: 258| 227|template inline void Serialize(Stream& s, uint8_t a ) { ser_writedata8(s, a); } _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorI6CTxOutNS5_9allocatorIS7_EEEEEERS3_RKT_: 1133| 704| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutNSt3__19allocatorIS5_EEEvRT_RKNS6_6vectorIT0_T1_EE: 846| 704|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 704| } else { 859| 704| Serialize(os, Using>(v)); 860| 704| } 861| 704|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS9_9allocatorISB_EEEEEQ12SerializableIT0_T_EEvRSJ_RKSI_: 753| 704|{ 754| 704| a.Serialize(os); 755| 704|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorI6CTxOutNS3_9allocatorIS5_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 482| 704| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorI6CTxOutNS8_9allocatorISA_EEEEEEvRT_RKT0_: 662| 704| { 663| 704| Formatter formatter; 664| 704| WriteCompactSize(s, v.size()); 665| 49.6k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 49.6k, False: 704] ------------------ 666| 49.6k| formatter.Ser(s, elem); 667| 49.6k| } 668| 704| } _ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutEEvRT_RKT0_: 774| 49.6k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE6CTxOutQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 49.6k|{ 754| 49.6k| a.Serialize(os); 755| 49.6k|} _ZNK6CTxOut9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 222| 49.6k| { \ 223| 49.6k| static_assert(std::is_same::value, "Serialize type mismatch"); \ 224| 49.6k| Ser(s, *this); \ 225| 49.6k| } \ _ZN6CTxOut3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_RKS_: 178| 49.6k| static void Ser(Stream& s, const cls& obj) { SerializationOps(obj, s, ActionSerialize{}); } \ _ZN15ActionSerialize16SerReadWriteManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEEvRT_DpRKT0_: 1013| 49.6k| { 1014| 49.6k| ::SerializeMany(s, args...); 1015| 49.6k| } _Z13SerializeManyI12ParamsStreamIR10HashWriter20TransactionSerParamsEJl7CScriptEEvRT_DpRKT0_: 995| 49.6k|{ 996| 49.6k| (::Serialize(s, args), ...); 997| 49.6k|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEvRT_l: 263| 49.6k|template inline void Serialize(Stream& s, int64_t a ) { ser_writedata64(s, a); } _ZN12ParamsStreamIR10HashWriter20TransactionSerParamsElsINSt3__16vectorINS6_IhNS5_9allocatorIhEEEENS7_IS9_EEEEEERS3_RKT_: 1133| 34.8k| template ParamsStream& operator<<(const U& obj) { ::Serialize(*this, obj); return *this; } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS5_9allocatorIhEEEENS7_IS9_EEEvRT_RKNS6_IT0_T1_EE: 846| 34.8k|{ 847| | if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| | WriteCompactSize(os, v.size()); 849| | if (!v.empty()) os.write(MakeByteSpan(v)); 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| 34.8k| } else { 859| 34.8k| Serialize(os, Using>(v)); 860| 34.8k| } 861| 34.8k|} _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINSA_IhNS9_9allocatorIhEEEENSB_ISD_EEEEEQ12SerializableIT0_T_EEvRSK_RKSJ_: 753| 34.8k|{ 754| 34.8k| a.Serialize(os); 755| 34.8k|} _ZNK7WrapperI15VectorFormatterI16DefaultFormatterERKNSt3__16vectorINS4_IhNS3_9allocatorIhEEEENS5_IS7_EEEEE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 482| 34.8k| template void Serialize(Stream &s) const { Formatter().Ser(s, m_object); } _ZN15VectorFormatterI16DefaultFormatterE3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorINS9_IhNS8_9allocatorIhEEEENSA_ISC_EEEEEEvRT_RKT0_: 662| 34.8k| { 663| 34.8k| Formatter formatter; 664| 34.8k| WriteCompactSize(s, v.size()); 665| 346k| for (const typename V::value_type& elem : v) { ------------------ | Branch (665:49): [True: 346k, False: 34.8k] ------------------ 666| 346k| formatter.Ser(s, elem); 667| 346k| } 668| 34.8k| } _ZN16DefaultFormatter3SerI12ParamsStreamIR10HashWriter20TransactionSerParamsENSt3__16vectorIhNS6_9allocatorIhEEEEEEvRT_RKT0_: 774| 346k| static void Ser(Stream& s, const T& t) { Serialize(s, t); } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEhNSt3__19allocatorIhEEEvRT_RKNS5_6vectorIT0_T1_EE: 846| 346k|{ 847| 346k| if constexpr (BasicByte) { // Use optimized version for unformatted basic bytes 848| 346k| WriteCompactSize(os, v.size()); 849| 346k| if (!v.empty()) os.write(MakeByteSpan(v)); ------------------ | Branch (849:13): [True: 19.8k, False: 327k] ------------------ 850| | } else if constexpr (std::is_same_v) { 851| | // A special case for std::vector, as dereferencing 852| | // std::vector::const_iterator does not result in a const bool& 853| | // due to std::vector's special casing for bool arguments. 854| | WriteCompactSize(os, v.size()); 855| | for (bool elem : v) { 856| | ::Serialize(os, elem); 857| | } 858| | } else { 859| | Serialize(os, Using>(v)); 860| | } 861| 346k|} _ZNK12ParamsStreamIR10HashWriter20TransactionSerParamsE9GetParamsIS2_EERKDav: 1144| 704| { 1145| 704| if constexpr (std::is_convertible_v) { 1146| 704| return m_params; 1147| | } else { 1148| | return m_substream.template GetParams

(); 1149| | } 1150| 704| } _Z9SerializeI10HashWriter13ParamsWrapperI20TransactionSerParamsK12CTransactionEQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 704|{ 754| 704| a.Serialize(os); 755| 704|} _ZNK13ParamsWrapperI20TransactionSerParamsK12CTransactionE9SerializeI10HashWriterEEvRT_: 1199| 704| { 1200| 704| ParamsStream ss{s, m_params}; 1201| 704| ::Serialize(ss, m_object); 1202| 704| } _Z9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsE12CTransactionQ12SerializableIT0_T_EEvRS7_RKS6_: 753| 704|{ 754| 704| a.Serialize(os); 755| 704|} _Z9UCharCastPKSt4byte: 287| 808k|inline const unsigned char* UCharCast(const std::byte* c) { return reinterpret_cast(c); } _ZNK4SpanIKSt4byteE4sizeEv: 187| 809k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 811k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIhE4dataEv: 174| 6.80M| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE4dataEv: 174| 171k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanISt4byteE4sizeEv: 187| 17.9M| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteE4dataEv: 174| 5.96M| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKSt4byteE5beginEv: 175| 656k| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanIKSt4byteE3endEv: 176| 656k| constexpr C* end() const noexcept { return m_data + m_size; } _ZNK4SpanIKhE10size_bytesEv: 188| 171k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E: 259| 171k|{ 260| 171k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 171k|} _Z12MakeByteSpanIRKNSt3__16vectorIhNS0_9allocatorIhEEEEE4SpanIKSt4byteEOT_: 270| 39.7k|{ 271| 39.7k| return AsBytes(Span{std::forward(v)}); 272| 39.7k|} _ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE: 172| 39.7k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m: 119| 1.46M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK4SpanIjE4dataEv: 174| 309k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIjE10size_bytesEv: 188| 309k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIjE4SpanIKSt4byteES0_IT_E: 259| 224k|{ 260| 224k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 224k|} _ZNK4SpanIhE10size_bytesEv: 188| 6.80M| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIhE4SpanIKSt4byteES0_IT_E: 259| 973k|{ 260| 973k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 973k|} _ZNK4SpanItE4dataEv: 174| 2.27k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanItE10size_bytesEv: 188| 2.27k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesItE4SpanIKSt4byteES0_IT_E: 259| 1.19k|{ 260| 1.19k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 1.19k|} _ZNK4SpanImE4dataEv: 174| 142k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanImE10size_bytesEv: 188| 142k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesImE4SpanIKSt4byteES0_IT_E: 259| 95.3k|{ 260| 95.3k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 95.3k|} _Z12MakeByteSpanIRK9prevectorILj28EhjiEE4SpanIKSt4byteEOT_: 270| 19.0k|{ 271| 19.0k| return AsBytes(Span{std::forward(v)}); 272| 19.0k|} _ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 5.96M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E: 264| 5.83M|{ 265| 5.83M| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 5.83M|} _ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m: 119| 6.76M| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesItE4SpanISt4byteES0_IT_E: 264| 1.08k|{ 265| 1.08k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 1.08k|} _ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m: 119| 2.27k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E: 264| 84.8k|{ 265| 84.8k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 84.8k|} _ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m: 119| 309k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesImE4SpanISt4byteES0_IT_E: 264| 47.0k|{ 265| 47.0k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 47.0k|} _ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m: 119| 142k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanIKhEC2INSt3__14spanIS0_Lm18446744073709551615EEEEERT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE: 165| 1.32k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKhEC2INSt3__15arrayIhLm32EEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS6_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalIS8_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS8_EE4sizeEEmEE5valueEDnE4typeE: 172| 110k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKhEC2I9prevectorILj28EhjiEEERKT_NSt3__19enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS8_14remove_pointerIDTcldtclsr3stdE7declvalIS7_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS7_EE4sizeEEmEE5valueEDnE4typeE: 172| 19.0k| : m_data(other.data()), m_size(other.size()){} _Z20MakeWritableByteSpanIRNSt3__15arrayIhLm32EEEE4SpanISt4byteEOT_: 275| 41.5k|{ 276| 41.5k| return AsWritableBytes(Span{std::forward(v)}); 277| 41.5k|} _ZN4SpanIhEC2INSt3__15arrayIhLm32EEEEERT_NS2_9enable_ifIXaaaantsr7is_SpanIS5_EE5valuesr3std14is_convertibleIPA_NS2_14remove_pointerIDTcldtclsr3stdE7declvalIS6_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS6_EE4sizeEEmEE5valueEDnE4typeE: 165| 41.5k| : m_data(other.data()), m_size(other.size()){} _ZN10DataStreamC2E4SpanIKhE: 165| 1.32k| explicit DataStream(Span sp) : DataStream{AsBytes(sp)} {} _ZN10DataStreamC2E4SpanIKSt4byteE: 166| 1.32k| explicit DataStream(Span sp) : vch(sp.data(), sp.data() + sp.size()) {} _ZNK10DataStream5emptyEv: 182| 477| bool empty() const { return vch.size() == m_read_pos; } _ZN10DataStream4readE4SpanISt4byteE: 219| 5.96M| { 220| 5.96M| if (dst.size() == 0) return; ------------------ | Branch (220:13): [True: 0, False: 5.96M] ------------------ 221| | 222| | // Read from the beginning of the buffer 223| 5.96M| auto next_read_pos{CheckedAdd(m_read_pos, dst.size())}; 224| 5.96M| if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { ------------------ | Branch (224:13): [True: 0, False: 5.96M] | Branch (224:43): [True: 548, False: 5.96M] ------------------ 225| 548| throw std::ios_base::failure("DataStream::read(): end of data"); 226| 548| } 227| 5.96M| memcpy(dst.data(), &vch[m_read_pos], dst.size()); 228| 5.96M| if (next_read_pos.value() == vch.size()) { ------------------ | Branch (228:13): [True: 1.14k, False: 5.96M] ------------------ 229| 1.14k| m_read_pos = 0; 230| 1.14k| vch.clear(); 231| 1.14k| return; 232| 1.14k| } 233| 5.96M| m_read_pos = next_read_pos.value(); 234| 5.96M| } _ZN10DataStream5writeE4SpanIKSt4byteE: 252| 656k| { 253| | // Write to the end of the buffer 254| 656k| vch.insert(vch.end(), src.begin(), src.end()); 255| 656k| } _ZN10DataStreamC2Ev: 164| 477| explicit DataStream() = default; _ZN10DataStreamrsIR20PrefilledTransactionEERS_OT_: 266| 1.32k| { 267| 1.32k| ::Unserialize(*this, obj); 268| 1.32k| return (*this); 269| 1.32k| } _ZN10DataStreamlsI20PrefilledTransactionEERS_RKT_: 259| 477| { 260| 477| ::Serialize(*this, obj); 261| 477| return (*this); 262| 477| } _ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m: 30| 5.27k| { 31| 5.27k| if (p != nullptr) ------------------ | Branch (31:13): [True: 5.27k, False: 0] ------------------ 32| 5.27k| memory_cleanse(p, sizeof(T) * n); 33| 5.27k| std::allocator{}.deallocate(p, n); 34| 5.27k| } _ZN25zero_after_free_allocatorISt4byteE8allocateEm: 25| 5.27k| { 26| 5.27k| return std::allocator{}.allocate(n); 27| 5.27k| } _Z14memory_cleansePvm: 15| 5.28k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 5.28k| 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| 5.28k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 5.28k|#endif 35| 5.28k|} _Z13LeaveCriticalv: 76| 2|inline void LeaveCritical() {} _Z10DeleteLockPv: 82| 4|inline void DeleteLock(void* cs) {} _Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_: 253| 2|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; } _Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b: 75| 2|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i: 157| 2| { 158| 2| 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| 2| Base::lock(); 164| 2| } _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib: 177| 2| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 178| 2| { 179| 2| if (fTry) ------------------ | Branch (179:13): [True: 0, False: 2] ------------------ 180| 0| TryEnter(pszName, pszFile, nLine); 181| 2| else 182| 2| Enter(pszName, pszFile, nLine); 183| 2| } _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev: 197| 2| { 198| 2| if (Base::owns_lock()) ------------------ | Branch (198:13): [True: 2, False: 0] ------------------ 199| 2| LeaveCritical(); 200| 2| } _ZN14AnnotatedMixinINSt3__15mutexEED2Ev: 94| 2| ~AnnotatedMixin() { 95| 2| DeleteLock((void*)this); 96| 2| } _ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev: 94| 2| ~AnnotatedMixin() { 95| 2| DeleteLock((void*)this); 96| 2| } _Z45prefilled_transaction_deserialize_fuzz_targetNSt3__14spanIKhLm18446744073709551615EEE: 51| 1.32k| { \ 52| 1.32k| try { \ 53| 1.32k| code \ 54| 1.32k| } catch (const invalid_fuzzing_input_exception&) { \ 55| 852| } \ 56| 1.32k| } deserialize.cpp:_ZN12_GLOBAL__N_127DeserializeFromFuzzingInputIR20PrefilledTransactionEEvNSt3__14spanIKhLm18446744073709551615EEEOT_: 109| 1.32k|{ 110| 1.32k| DataStream ds{buffer}; 111| 1.32k| try { 112| 1.32k| ds >> obj; 113| 1.32k| } catch (const std::ios_base::failure&) { 114| 852| throw invalid_fuzzing_input_exception(); 115| 852| } 116| 477| assert(buffer.empty() || !Serialize(obj).empty()); 117| 477|} deserialize.cpp:_ZN12_GLOBAL__N_19SerializeI20PrefilledTransactionEE10DataStreamRKT_: 93| 477|{ 94| 477| DataStream ds{}; 95| 477| ds << obj; 96| 477| return ds; 97| 477|} LLVMFuzzerTestOneInput: 222| 1.32k|{ 223| 1.32k| test_one_input({data, size}); 224| 1.32k| return 0; 225| 1.32k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 1.32k|{ 84| 1.32k| CheckGlobals check{}; 85| 1.32k| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 1.32k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 1.32k|} _ZN12CheckGlobalsC2Ev: 56| 1.32k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 1.32k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 1.32k| { 18| 1.32k| g_used_g_prng = false; 19| 1.32k| g_seeded_g_prng_zero = false; 20| 1.32k| g_used_system_time = false; 21| 1.32k| SetMockTime(0s); 22| 1.32k| } _ZN16CheckGlobalsImplD2Ev: 24| 1.32k| { 25| 1.32k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 1.32k] | 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| 1.32k| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 1.32k] ------------------ 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| 1.32k| } _ZN17BasicTestingSetupD2Ev: 199| 2|{ 200| 2| m_node.ecc_context.reset(); 201| 2| m_node.kernel.reset(); 202| | if constexpr (!G_FUZZING) { 203| | SetMockTime(0s); // Reset mocktime for following tests 204| | } 205| 2| LogInstance().DisconnectTestLogger(); 206| 2| if (m_has_custom_datadir) { ------------------ | Branch (206:9): [True: 0, False: 2] ------------------ 207| | // Only remove the lock file, preserve the data directory. 208| 0| UnlockDirectory(m_path_lock, ".lock"); 209| 0| fs::remove(m_path_lock / ".lock"); 210| 2| } else { 211| 2| fs::remove_all(m_path_root); 212| 2| } 213| 2| gArgs.ClearArgs(); 214| 2|} _ZN12StdLockGuardC2ER8StdMutex: 73| 2| explicit StdLockGuard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard(cs) {} _ZN9base_blobILj256EE5beginEv: 115| 2.11k| constexpr unsigned char* begin() { return m_data.data(); } _ZN7uint256C2Ev: 205| 42.2k| constexpr uint256() = default; _ZN9base_blobILj256EEC2Ev: 35| 42.2k| constexpr base_blob() : m_data() {} _ZN9base_blobILj256EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 133| 41.5k| { 134| 41.5k| s.read(MakeWritableByteSpan(m_data)); 135| 41.5k| } _ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 127| 38.0k| { 128| 38.0k| s << Span(m_data); 129| 38.0k| } _ZNK9base_blobILj256EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 127| 72.9k| { 128| 72.9k| s << Span(m_data); 129| 72.9k| } _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 1.32k|{ 53| 1.32k| 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| 1.32k| ) { 58| 1.32k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.32k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.32k| } 62| 1.32k| return std::forward(val); 63| 1.32k|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 1.32k|{ 53| 1.32k| 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| 1.32k| ) { 58| 1.32k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.32k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.32k| } 62| 1.32k| return std::forward(val); 63| 1.32k|} _Z16AdditionOverflowImEbT_S0_: 16| 5.96M|{ 17| 5.96M| 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| 5.96M| return std::numeric_limits::max() - i < j; 23| 5.96M|} _Z10CheckedAddImENSt3__18optionalIT_EES2_S2_: 27| 5.96M|{ 28| 5.96M| if (AdditionOverflow(i, j)) { ------------------ | Branch (28:9): [True: 0, False: 5.96M] ------------------ 29| 0| return std::nullopt; 30| 0| } 31| 5.96M| return i + j; 32| 5.96M|} _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 1.32k|{ 43| 1.32k| Assert(mock_time_in >= 0s); ------------------ | | 85| 1.32k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 1.32k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 1.32k|} _ZN12TokenPipeEndD2Ev: 34| 4|{ 35| 4| Close(); 36| 4|} _ZN12TokenPipeEnd5CloseEv: 77| 4|{ 78| 4| if (m_fd != -1) close(m_fd); ------------------ | Branch (78:9): [True: 4, False: 0] ------------------ 79| 4| m_fd = -1; 80| 4|} _ZN22transaction_identifierILb0EEC2Ev: 30| 41.5k| transaction_identifier() : m_wrapped{} {} _ZN22transaction_identifierILb0EE11UnserializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 58| 41.5k| template void Unserialize(Stream& s) { m_wrapped.Unserialize(s); } _ZN22transaction_identifierILb0EE11FromUint256ERK7uint256: 40| 477| static transaction_identifier FromUint256(const uint256& id) { return {id}; } _ZN22transaction_identifierILb0EEC2ERK7uint256: 16| 477| transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {} _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10DataStream20TransactionSerParamsEEEvRT_: 57| 38.0k| template void Serialize(Stream& s) const { m_wrapped.Serialize(s); } _ZN22transaction_identifierILb1EE11FromUint256ERK7uint256: 40| 477| static transaction_identifier FromUint256(const uint256& id) { return {id}; } _ZN22transaction_identifierILb1EEC2ERK7uint256: 16| 477| transaction_identifier(const uint256& wrapped) : m_wrapped{wrapped} {} _ZNK22transaction_identifierILb0EE9ToUint256Ev: 39| 250| const uint256& ToUint256() const LIFETIMEBOUND { return m_wrapped; } _ZNK22transaction_identifierILb0EE9SerializeI12ParamsStreamIR10HashWriter20TransactionSerParamsEEEvRT_: 57| 72.9k| template void Serialize(Stream& s) const { m_wrapped.Serialize(s); }