_ZN11AddrManImplD2Ev: 128| 2|{ 129| 2| nKey.SetNull(); 130| 2|} _ZN7AddrManD2Ev: 1275| 2|AddrMan::~AddrMan() = default; _ZN6BanManD2Ev: 25| 2|{ 26| 2| DumpBanlist(); 27| 2|} _ZN6BanMan11DumpBanlistEv: 49| 2|{ 50| 2| static Mutex dump_mutex; 51| 2| LOCK(dump_mutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 52| | 53| 2| banmap_t banmap; 54| 2| { 55| 2| LOCK(m_banned_mutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 56| 2| SweepBanned(); 57| 2| if (!m_is_dirty) return; ------------------ | Branch (57:13): [True: 2, False: 0] ------------------ 58| 0| banmap = m_banned; 59| 0| m_is_dirty = false; 60| 0| } 61| | 62| 0| const auto start{SteadyClock::now()}; 63| 0| if (!m_ban_db.Write(banmap)) { ------------------ | Branch (63:9): [True: 0, False: 0] ------------------ 64| 0| LOCK(m_banned_mutex); ------------------ | | 257| 0|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 0|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 0|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 0|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 65| 0| m_is_dirty = true; 66| 0| } 67| | 68| 0| LogDebug(BCLog::NET, "Flushed %d banned node addresses/subnets to disk %dms\n", banmap.size(), ------------------ | | 280| 0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__) | | ------------------ | | | | 273| 0| do { \ | | | | 274| 0| if (LogAcceptCategory((category), (level))) { \ | | | | ------------------ | | | | | Branch (274:13): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| LogPrintLevel_(category, level, __VA_ARGS__); \ | | | | ------------------ | | | | | | 255| 0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__) | | | | ------------------ | | | | 276| 0| } \ | | | | 277| 0| } while (0) | | | | ------------------ | | | | | Branch (277:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 69| 0| Ticks(SteadyClock::now() - start)); 70| 0|} _ZN6BanMan11SweepBannedEv: 183| 2|{ 184| 2| AssertLockHeld(m_banned_mutex); ------------------ | | 142| 2|#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs) ------------------ 185| | 186| 2| int64_t now = GetTime(); 187| 2| bool notify_ui = false; 188| 2| banmap_t::iterator it = m_banned.begin(); 189| 2| while (it != m_banned.end()) { ------------------ | Branch (189:12): [True: 0, False: 2] ------------------ 190| 0| CSubNet sub_net = (*it).first; 191| 0| CBanEntry ban_entry = (*it).second; 192| 0| if (!sub_net.IsValid() || now > ban_entry.nBanUntil) { ------------------ | Branch (192:13): [True: 0, False: 0] | Branch (192:35): [True: 0, False: 0] ------------------ 193| 0| m_banned.erase(it++); 194| 0| m_is_dirty = true; 195| 0| notify_ui = true; 196| 0| LogDebug(BCLog::NET, "Removed banned node address/subnet: %s\n", sub_net.ToString()); ------------------ | | 280| 0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__) | | ------------------ | | | | 273| 0| do { \ | | | | 274| 0| if (LogAcceptCategory((category), (level))) { \ | | | | ------------------ | | | | | Branch (274:13): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| LogPrintLevel_(category, level, __VA_ARGS__); \ | | | | ------------------ | | | | | | 255| 0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__) | | | | ------------------ | | | | 276| 0| } \ | | | | 277| 0| } while (0) | | | | ------------------ | | | | | Branch (277:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 197| 0| } else { 198| 0| ++it; 199| 0| } 200| 0| } 201| | 202| | // update UI 203| 2| if (notify_ui && m_client_interface) { ------------------ | Branch (203:9): [True: 0, False: 2] | Branch (203:22): [True: 0, False: 0] ------------------ 204| 0| m_client_interface->BannedListChanged(); 205| 0| } 206| 2|} _ZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEE4LoopEb: 73| 0| { 74| 0| std::condition_variable& cond = fMaster ? m_master_cv : m_worker_cv; ------------------ | Branch (74:41): [True: 0, False: 0] ------------------ 75| 0| std::vector vChecks; 76| 0| vChecks.reserve(nBatchSize); 77| 0| unsigned int nNow = 0; 78| 0| std::optional local_result; 79| 0| bool do_work; 80| 0| do { 81| 0| { 82| 0| WAIT_LOCK(m_mutex, lock); ------------------ | | 262| 0|#define WAIT_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) ------------------ 83| | // first do the clean-up of the previous loop run (allowing us to do it in the same critsect) 84| 0| if (nNow) { ------------------ | Branch (84:21): [True: 0, False: 0] ------------------ 85| 0| if (local_result.has_value() && !m_result.has_value()) { ------------------ | Branch (85:25): [True: 0, False: 0] | Branch (85:53): [True: 0, False: 0] ------------------ 86| 0| std::swap(local_result, m_result); 87| 0| } 88| 0| nTodo -= nNow; 89| 0| if (nTodo == 0 && !fMaster) { ------------------ | Branch (89:25): [True: 0, False: 0] | Branch (89:39): [True: 0, False: 0] ------------------ 90| | // We processed the last element; inform the master it can exit and return the result 91| 0| m_master_cv.notify_one(); 92| 0| } 93| 0| } else { 94| | // first iteration 95| 0| nTotal++; 96| 0| } 97| | // logically, the do loop starts here 98| 4| while (queue.empty() && !m_request_stop) { ------------------ | Branch (98:24): [True: 4, False: 18.4E] | Branch (98:41): [True: 0, False: 4] ------------------ 99| 0| if (fMaster && nTodo == 0) { ------------------ | Branch (99:25): [True: 0, False: 0] | Branch (99:36): [True: 0, False: 0] ------------------ 100| 0| nTotal--; 101| 0| std::optional to_return = std::move(m_result); 102| | // reset the status for new work later 103| 0| m_result = std::nullopt; 104| | // return the current status 105| 0| return to_return; 106| 0| } 107| 0| nIdle++; 108| 0| cond.wait(lock); // wait 109| 0| nIdle--; 110| 0| } 111| 4| if (m_request_stop) { ------------------ | Branch (111:21): [True: 4, False: 18.4E] ------------------ 112| | // return value does not matter, because m_request_stop is only set in the destructor. 113| 4| return std::nullopt; 114| 4| } 115| | 116| | // Decide how many work units to process now. 117| | // * Do not try to do everything at once, but aim for increasingly smaller batches so 118| | // all workers finish approximately simultaneously. 119| | // * Try to account for idle jobs which will instantly start helping. 120| | // * Don't do batches smaller than 1 (duh), or larger than nBatchSize. 121| 18.4E| nNow = std::max(1U, std::min(nBatchSize, (unsigned int)queue.size() / (nTotal + nIdle + 1))); 122| 18.4E| auto start_it = queue.end() - nNow; 123| 18.4E| vChecks.assign(std::make_move_iterator(start_it), std::make_move_iterator(queue.end())); 124| 18.4E| queue.erase(start_it, queue.end()); 125| | // Check whether we need to do work at all 126| 18.4E| do_work = !m_result.has_value(); 127| 18.4E| } 128| | // execute work 129| 18.4E| if (do_work) { ------------------ | Branch (129:17): [True: 0, False: 18.4E] ------------------ 130| 0| for (T& check : vChecks) { ------------------ | Branch (130:31): [True: 0, False: 0] ------------------ 131| 0| local_result = check(); 132| 0| if (local_result.has_value()) break; ------------------ | Branch (132:25): [True: 0, False: 0] ------------------ 133| 0| } 134| 0| } 135| 18.4E| vChecks.clear(); 136| 18.4E| } while (true); ------------------ | Branch (136:18): [Folded - Ignored] ------------------ 137| 0| } _ZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEED2Ev: 192| 2| { 193| 2| WITH_LOCK(m_mutex, m_request_stop = true); ------------------ | | 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ 194| 2| m_worker_cv.notify_all(); 195| 4| for (std::thread& t : m_worker_threads) { ------------------ | Branch (195:29): [True: 4, False: 2] ------------------ 196| 4| t.join(); 197| 4| } 198| 2| } _ZN16CCoinsCacheEntryD2Ev: 173| 2| { 174| 2| SetClean(); 175| 2| } _ZN16CCoinsCacheEntry8SetCleanEv: 181| 2| { 182| 2| if (!m_flags) return; ------------------ | Branch (182:13): [True: 0, False: 2] ------------------ 183| 2| m_next->second.m_prev = m_prev; 184| 2| m_prev->second.m_next = m_next; 185| 2| m_flags = 0; 186| 2| m_prev = m_next = nullptr; 187| 2| } _ZN10CCoinsViewD2Ev: 335| 6| virtual ~CCoinsView() = default; _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| 117k|{ 55| 117k|#ifdef bitcoin_builtin_bswap32 56| 117k| return bitcoin_builtin_bswap32(x); ------------------ | | 24| 117k|# 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| 117k|} _Z17internal_bswap_64m: 64| 340M|{ 65| 340M|#ifdef bitcoin_builtin_bswap64 66| 340M| return bitcoin_builtin_bswap64(x); ------------------ | | 27| 340M|# 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| 340M|} _Z16le16toh_internalt: 29| 99|{ 30| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_16(little_endian_16bits); 31| 99| else return little_endian_16bits; 32| 99|} _Z16htobe32_internalj: 34| 117k|{ 35| 117k| if constexpr (std::endian::native == std::endian::little) return internal_bswap_32(host_32bits); 36| | else return host_32bits; 37| 117k|} _Z16le32toh_internalj: 49| 74|{ 50| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_32(little_endian_32bits); 51| 74| else return little_endian_32bits; 52| 74|} _Z16htobe64_internalm: 54| 122M|{ 55| 122M| if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(host_64bits); 56| | else return host_64bits; 57| 122M|} _Z16be64toh_internalm: 64| 217M|{ 65| 217M| if constexpr (std::endian::native == std::endian::little) return internal_bswap_64(big_endian_64bits); 66| | else return big_endian_64bits; 67| 217M|} _Z16le64toh_internalm: 69| 156|{ 70| | if constexpr (std::endian::native == std::endian::big) return internal_bswap_64(little_endian_64bits); 71| 156| else return little_endian_64bits; 72| 156|} _ZN13AES256EncryptC2EPKh: 14| 5.30k|{ 15| 5.30k| AES256_init(&ctx, key); 16| 5.30k|} _ZN13AES256EncryptD2Ev: 19| 5.30k|{ 20| 5.30k| memset(&ctx, 0, sizeof(ctx)); 21| 5.30k|} _ZNK13AES256Encrypt7EncryptEPhPKh: 24| 32.1k|{ 25| 32.1k| AES256_encrypt(&ctx, 1, ciphertext, plaintext); 26| 32.1k|} _ZN13AES256DecryptC2EPKh: 29| 14.8k|{ 30| 14.8k| AES256_init(&ctx, key); 31| 14.8k|} _ZN13AES256DecryptD2Ev: 34| 14.8k|{ 35| 14.8k| memset(&ctx, 0, sizeof(ctx)); 36| 14.8k|} _ZNK13AES256Decrypt7DecryptEPhPKh: 39| 37.1k|{ 40| 37.1k| AES256_decrypt(&ctx, 1, plaintext, ciphertext); 41| 37.1k|} _ZN16AES256CBCEncryptC2EPKhS1_b: 122| 5.30k| : enc(key), pad(padIn) 123| 5.30k|{ 124| 5.30k| memcpy(iv, ivIn, AES_BLOCKSIZE); 125| 5.30k|} _ZNK16AES256CBCEncrypt7EncryptEPKhiPh: 128| 5.30k|{ 129| 5.30k| return CBCEncrypt(enc, iv, data, size, pad, out); 130| 5.30k|} _ZN16AES256CBCEncryptD2Ev: 133| 5.30k|{ 134| 5.30k| memset(iv, 0, sizeof(iv)); 135| 5.30k|} _ZN16AES256CBCDecryptC2EPKhS1_b: 138| 14.8k| : dec(key), pad(padIn) 139| 14.8k|{ 140| 14.8k| memcpy(iv, ivIn, AES_BLOCKSIZE); 141| 14.8k|} _ZNK16AES256CBCDecrypt7DecryptEPKhiPh: 145| 14.8k|{ 146| 14.8k| return CBCDecrypt(dec, iv, data, size, pad, out); 147| 14.8k|} _ZN16AES256CBCDecryptD2Ev: 150| 14.8k|{ 151| 14.8k| memset(iv, 0, sizeof(iv)); 152| 14.8k|} aes.cpp:_ZL10CBCEncryptI13AES256EncryptEiRKT_PKhS5_ibPh: 46| 5.30k|{ 47| 5.30k| int written = 0; 48| 5.30k| int padsize = size % AES_BLOCKSIZE; 49| 5.30k| unsigned char mixed[AES_BLOCKSIZE]; 50| | 51| 5.30k| if (!data || !size || !out) ------------------ | Branch (51:9): [True: 1.34k, False: 3.96k] | Branch (51:18): [True: 99, False: 3.86k] | Branch (51:27): [True: 0, False: 3.86k] ------------------ 52| 1.44k| return 0; 53| | 54| 3.86k| if (!pad && padsize != 0) ------------------ | Branch (54:9): [True: 0, False: 3.86k] | Branch (54:17): [True: 0, False: 0] ------------------ 55| 0| return 0; 56| | 57| 3.86k| memcpy(mixed, iv, AES_BLOCKSIZE); 58| | 59| | // Write all but the last block 60| 32.1k| while (written + AES_BLOCKSIZE <= size) { ------------------ | Branch (60:12): [True: 28.2k, False: 3.86k] ------------------ 61| 481k| for (int i = 0; i != AES_BLOCKSIZE; i++) ------------------ | Branch (61:25): [True: 452k, False: 28.2k] ------------------ 62| 452k| mixed[i] ^= *data++; 63| 28.2k| enc.Encrypt(out + written, mixed); 64| 28.2k| memcpy(mixed, out + written, AES_BLOCKSIZE); 65| 28.2k| written += AES_BLOCKSIZE; 66| 28.2k| } 67| 3.86k| if (pad) { ------------------ | Branch (67:9): [True: 3.86k, False: 0] ------------------ 68| | // For all that remains, pad each byte with the value of the remaining 69| | // space. If there is none, pad by a full block. 70| 7.89k| for (int i = 0; i != padsize; i++) ------------------ | Branch (70:25): [True: 4.03k, False: 3.86k] ------------------ 71| 4.03k| mixed[i] ^= *data++; 72| 61.6k| for (int i = padsize; i != AES_BLOCKSIZE; i++) ------------------ | Branch (72:31): [True: 57.7k, False: 3.86k] ------------------ 73| 57.7k| mixed[i] ^= AES_BLOCKSIZE - padsize; 74| 3.86k| enc.Encrypt(out + written, mixed); 75| 3.86k| written += AES_BLOCKSIZE; 76| 3.86k| } 77| 3.86k| return written; 78| 3.86k|} aes.cpp:_ZL10CBCDecryptI13AES256DecryptEiRKT_PKhS5_ibPh: 82| 14.8k|{ 83| 14.8k| int written = 0; 84| 14.8k| bool fail = false; 85| 14.8k| const unsigned char* prev = iv; 86| | 87| 14.8k| if (!data || !size || !out) ------------------ | Branch (87:9): [True: 2.72k, False: 12.1k] | Branch (87:18): [True: 950, False: 11.2k] | Branch (87:27): [True: 0, False: 11.2k] ------------------ 88| 3.67k| return 0; 89| | 90| 11.2k| if (size % AES_BLOCKSIZE != 0) ------------------ | Branch (90:9): [True: 6.71k, False: 4.50k] ------------------ 91| 6.71k| return 0; 92| | 93| | // Decrypt all data. Padding will be checked in the output. 94| 41.6k| while (written != size) { ------------------ | Branch (94:12): [True: 37.1k, False: 4.50k] ------------------ 95| 37.1k| dec.Decrypt(out, data + written); 96| 631k| for (int i = 0; i != AES_BLOCKSIZE; i++) ------------------ | Branch (96:25): [True: 594k, False: 37.1k] ------------------ 97| 594k| *out++ ^= prev[i]; 98| 37.1k| prev = data + written; 99| 37.1k| written += AES_BLOCKSIZE; 100| 37.1k| } 101| | 102| | // When decrypting padding, attempt to run in constant-time 103| 4.50k| if (pad) { ------------------ | Branch (103:9): [True: 4.50k, False: 0] ------------------ 104| | // If used, padding size is the value of the last decrypted byte. For 105| | // it to be valid, It must be between 1 and AES_BLOCKSIZE. 106| 4.50k| unsigned char padsize = *--out; 107| 4.50k| fail = !padsize | (padsize > AES_BLOCKSIZE); 108| | 109| | // If not well-formed, treat it as though there's no padding. 110| 4.50k| padsize *= !fail; 111| | 112| | // All padding must equal the last byte otherwise it's not well-formed 113| 76.5k| for (int i = AES_BLOCKSIZE; i != 0; i--) ------------------ | Branch (113:37): [True: 72.0k, False: 4.50k] ------------------ 114| 72.0k| fail |= ((i > AES_BLOCKSIZE - padsize) & (*out-- != padsize)); 115| | 116| 4.50k| written -= padsize; 117| 4.50k| } 118| 4.50k| return written * !fail; 119| 11.2k|} _ZN15ChaCha20AlignedD2Ev: 43| 6|{ 44| 6| memory_cleanse(input, sizeof(input)); 45| 6|} _ZN8ChaCha20D2Ev: 333| 6|{ 334| 6| memory_cleanse(m_buffer.data(), m_buffer.size()); 335| 6|} _Z9WriteBE32ITk8ByteTypehEvPT_j: 96| 117k|{ 97| 117k| uint32_t v = htobe32_internal(x); 98| 117k| memcpy(ptr, &v, 4); 99| 117k|} _Z9WriteBE64ITk8ByteTypehEvPT_m: 103| 122M|{ 104| 122M| uint64_t v = htobe64_internal(x); 105| 122M| memcpy(ptr, &v, 8); 106| 122M|} _Z8ReadBE64ITk8ByteTypehEmPKT_: 81| 217M|{ 82| 217M| uint64_t x; 83| 217M| memcpy(&x, ptr, 8); 84| 217M| return be64toh_internal(x); 85| 217M|} AES256_init: 538| 20.1k|void AES256_init(AES256_ctx* ctx, const unsigned char* key32) { 539| 20.1k| AES_setup(ctx->rk, key32, 8, 14); 540| 20.1k|} AES256_encrypt: 542| 32.1k|void AES256_encrypt(const AES256_ctx* ctx, size_t blocks, unsigned char* cipher16, const unsigned char* plain16) { 543| 64.3k| while (blocks--) { ------------------ | Branch (543:12): [True: 32.1k, False: 32.1k] ------------------ 544| 32.1k| AES_encrypt(ctx->rk, 14, cipher16, plain16); 545| 32.1k| cipher16 += 16; 546| 32.1k| plain16 += 16; 547| 32.1k| } 548| 32.1k|} AES256_decrypt: 550| 37.1k|void AES256_decrypt(const AES256_ctx* ctx, size_t blocks, unsigned char* plain16, const unsigned char* cipher16) { 551| 74.3k| while (blocks--) { ------------------ | Branch (551:12): [True: 37.1k, False: 37.1k] ------------------ 552| 37.1k| AES_decrypt(ctx->rk, 14, plain16, cipher16); 553| 37.1k| cipher16 += 16; 554| 37.1k| plain16 += 16; 555| 37.1k| } 556| 37.1k|} aes.cpp:_ZL9AES_setupP9AES_statePKhii: 408| 20.1k|{ 409| 20.1k| int i; 410| | 411| | /* The one-byte round constant */ 412| 20.1k| AES_state rcon = {{1,0,0,0,0,0,0,0}}; 413| | /* The number of the word being generated, modulo nkeywords */ 414| 20.1k| int pos = 0; 415| | /* The column representing the word currently being processed */ 416| 20.1k| AES_state column; 417| | 418| 323k| for (i = 0; i < nrounds + 1; i++) { ------------------ | Branch (418:17): [True: 302k, False: 20.1k] ------------------ 419| 302k| int b; 420| 2.72M| for (b = 0; b < 8; b++) { ------------------ | Branch (420:21): [True: 2.42M, False: 302k] ------------------ 421| 2.42M| rounds[i].slice[b] = 0; 422| 2.42M| } 423| 302k| } 424| | 425| | /* The first nkeywords round columns are just taken from the key directly. */ 426| 181k| for (i = 0; i < nkeywords; i++) { ------------------ | Branch (426:17): [True: 161k, False: 20.1k] ------------------ 427| 161k| int r; 428| 807k| for (r = 0; r < 4; r++) { ------------------ | Branch (428:21): [True: 646k, False: 161k] ------------------ 429| 646k| LoadByte(&rounds[i >> 2], *(key++), r, i & 3); 430| 646k| } 431| 161k| } 432| | 433| 20.1k| GetOneColumn(&column, &rounds[(nkeywords - 1) >> 2], (nkeywords - 1) & 3); 434| | 435| 1.07M| for (i = nkeywords; i < 4 * (nrounds + 1); i++) { ------------------ | Branch (435:25): [True: 1.04M, False: 20.1k] ------------------ 436| | /* Transform column */ 437| 1.04M| if (pos == 0) { ------------------ | Branch (437:13): [True: 141k, False: 908k] ------------------ 438| 141k| SubBytes(&column, 0); 439| 141k| KeySetupTransform(&column, &rcon); 440| 141k| MultX(&rcon); 441| 908k| } else if (nkeywords > 6 && pos == 4) { ------------------ | Branch (441:20): [True: 908k, False: 0] | Branch (441:37): [True: 121k, False: 787k] ------------------ 442| 121k| SubBytes(&column, 0); 443| 121k| } 444| 1.04M| if (++pos == nkeywords) pos = 0; ------------------ | Branch (444:13): [True: 121k, False: 928k] ------------------ 445| 1.04M| KeySetupColumnMix(&column, &rounds[i >> 2], &rounds[(i - nkeywords) >> 2], i & 3, (i - nkeywords) & 3); 446| 1.04M| } 447| 20.1k|} aes.cpp:_ZL8LoadByteP9AES_statehii: 25| 1.75M|static void LoadByte(AES_state* s, unsigned char byte, int r, int c) { 26| 1.75M| int i; 27| 15.7M| for (i = 0; i < 8; i++) { ------------------ | Branch (27:17): [True: 14.0M, False: 1.75M] ------------------ 28| 14.0M| s->slice[i] |= (byte & 1) << (r * 4 + c); 29| 14.0M| byte >>= 1; 30| 14.0M| } 31| 1.75M|} aes.cpp:_ZL12GetOneColumnP9AES_statePKS_i: 362| 20.1k|static void GetOneColumn(AES_state* s, const AES_state* a, int c) { 363| 20.1k| int b; 364| 181k| for (b = 0; b < 8; b++) { ------------------ | Branch (364:17): [True: 161k, False: 20.1k] ------------------ 365| 161k| s->slice[b] = (a->slice[b] >> c) & 0x1111; 366| 161k| } 367| 20.1k|} aes.cpp:_ZL8SubBytesP9AES_statei: 64| 1.23M|static void SubBytes(AES_state *s, int inv) { 65| | /* Load the bit slices */ 66| 1.23M| uint16_t U0 = s->slice[7], U1 = s->slice[6], U2 = s->slice[5], U3 = s->slice[4]; 67| 1.23M| uint16_t U4 = s->slice[3], U5 = s->slice[2], U6 = s->slice[1], U7 = s->slice[0]; 68| | 69| 1.23M| uint16_t T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16; 70| 1.23M| uint16_t T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, D; 71| 1.23M| uint16_t M1, M6, M11, M13, M15, M20, M21, M22, M23, M25, M37, M38, M39, M40; 72| 1.23M| uint16_t M41, M42, M43, M44, M45, M46, M47, M48, M49, M50, M51, M52, M53, M54; 73| 1.23M| uint16_t M55, M56, M57, M58, M59, M60, M61, M62, M63; 74| | 75| 1.23M| if (inv) { ------------------ | Branch (75:9): [True: 520k, False: 712k] ------------------ 76| 520k| uint16_t R5, R13, R17, R18, R19; 77| | /* Undo linear postprocessing */ 78| 520k| T23 = U0 ^ U3; 79| 520k| T22 = ~(U1 ^ U3); 80| 520k| T2 = ~(U0 ^ U1); 81| 520k| T1 = U3 ^ U4; 82| 520k| T24 = ~(U4 ^ U7); 83| 520k| R5 = U6 ^ U7; 84| 520k| T8 = ~(U1 ^ T23); 85| 520k| T19 = T22 ^ R5; 86| 520k| T9 = ~(U7 ^ T1); 87| 520k| T10 = T2 ^ T24; 88| 520k| T13 = T2 ^ R5; 89| 520k| T3 = T1 ^ R5; 90| 520k| T25 = ~(U2 ^ T1); 91| 520k| R13 = U1 ^ U6; 92| 520k| T17 = ~(U2 ^ T19); 93| 520k| T20 = T24 ^ R13; 94| 520k| T4 = U4 ^ T8; 95| 520k| R17 = ~(U2 ^ U5); 96| 520k| R18 = ~(U5 ^ U6); 97| 520k| R19 = ~(U2 ^ U4); 98| 520k| D = U0 ^ R17; 99| 520k| T6 = T22 ^ R17; 100| 520k| T16 = R13 ^ R19; 101| 520k| T27 = T1 ^ R18; 102| 520k| T15 = T10 ^ T27; 103| 520k| T14 = T10 ^ R18; 104| 520k| T26 = T3 ^ T16; 105| 712k| } else { 106| | /* Linear preprocessing. */ 107| 712k| T1 = U0 ^ U3; 108| 712k| T2 = U0 ^ U5; 109| 712k| T3 = U0 ^ U6; 110| 712k| T4 = U3 ^ U5; 111| 712k| T5 = U4 ^ U6; 112| 712k| T6 = T1 ^ T5; 113| 712k| T7 = U1 ^ U2; 114| 712k| T8 = U7 ^ T6; 115| 712k| T9 = U7 ^ T7; 116| 712k| T10 = T6 ^ T7; 117| 712k| T11 = U1 ^ U5; 118| 712k| T12 = U2 ^ U5; 119| 712k| T13 = T3 ^ T4; 120| 712k| T14 = T6 ^ T11; 121| 712k| T15 = T5 ^ T11; 122| 712k| T16 = T5 ^ T12; 123| 712k| T17 = T9 ^ T16; 124| 712k| T18 = U3 ^ U7; 125| 712k| T19 = T7 ^ T18; 126| 712k| T20 = T1 ^ T19; 127| 712k| T21 = U6 ^ U7; 128| 712k| T22 = T7 ^ T21; 129| 712k| T23 = T2 ^ T22; 130| 712k| T24 = T2 ^ T10; 131| 712k| T25 = T20 ^ T17; 132| 712k| T26 = T3 ^ T16; 133| 712k| T27 = T1 ^ T12; 134| 712k| D = U7; 135| 712k| } 136| | 137| | /* Non-linear transformation (shared between the forward and backward case) */ 138| 1.23M| M1 = T13 & T6; 139| 1.23M| M6 = T3 & T16; 140| 1.23M| M11 = T1 & T15; 141| 1.23M| M13 = (T4 & T27) ^ M11; 142| 1.23M| M15 = (T2 & T10) ^ M11; 143| 1.23M| M20 = T14 ^ M1 ^ (T23 & T8) ^ M13; 144| 1.23M| M21 = (T19 & D) ^ M1 ^ T24 ^ M15; 145| 1.23M| M22 = T26 ^ M6 ^ (T22 & T9) ^ M13; 146| 1.23M| M23 = (T20 & T17) ^ M6 ^ M15 ^ T25; 147| 1.23M| M25 = M22 & M20; 148| 1.23M| M37 = M21 ^ ((M20 ^ M21) & (M23 ^ M25)); 149| 1.23M| M38 = M20 ^ M25 ^ (M21 | (M20 & M23)); 150| 1.23M| M39 = M23 ^ ((M22 ^ M23) & (M21 ^ M25)); 151| 1.23M| M40 = M22 ^ M25 ^ (M23 | (M21 & M22)); 152| 1.23M| M41 = M38 ^ M40; 153| 1.23M| M42 = M37 ^ M39; 154| 1.23M| M43 = M37 ^ M38; 155| 1.23M| M44 = M39 ^ M40; 156| 1.23M| M45 = M42 ^ M41; 157| 1.23M| M46 = M44 & T6; 158| 1.23M| M47 = M40 & T8; 159| 1.23M| M48 = M39 & D; 160| 1.23M| M49 = M43 & T16; 161| 1.23M| M50 = M38 & T9; 162| 1.23M| M51 = M37 & T17; 163| 1.23M| M52 = M42 & T15; 164| 1.23M| M53 = M45 & T27; 165| 1.23M| M54 = M41 & T10; 166| 1.23M| M55 = M44 & T13; 167| 1.23M| M56 = M40 & T23; 168| 1.23M| M57 = M39 & T19; 169| 1.23M| M58 = M43 & T3; 170| 1.23M| M59 = M38 & T22; 171| 1.23M| M60 = M37 & T20; 172| 1.23M| M61 = M42 & T1; 173| 1.23M| M62 = M45 & T4; 174| 1.23M| M63 = M41 & T2; 175| | 176| 1.23M| if (inv){ ------------------ | Branch (176:9): [True: 520k, False: 712k] ------------------ 177| | /* Undo linear preprocessing */ 178| 520k| uint16_t P0 = M52 ^ M61; 179| 520k| uint16_t P1 = M58 ^ M59; 180| 520k| uint16_t P2 = M54 ^ M62; 181| 520k| uint16_t P3 = M47 ^ M50; 182| 520k| uint16_t P4 = M48 ^ M56; 183| 520k| uint16_t P5 = M46 ^ M51; 184| 520k| uint16_t P6 = M49 ^ M60; 185| 520k| uint16_t P7 = P0 ^ P1; 186| 520k| uint16_t P8 = M50 ^ M53; 187| 520k| uint16_t P9 = M55 ^ M63; 188| 520k| uint16_t P10 = M57 ^ P4; 189| 520k| uint16_t P11 = P0 ^ P3; 190| 520k| uint16_t P12 = M46 ^ M48; 191| 520k| uint16_t P13 = M49 ^ M51; 192| 520k| uint16_t P14 = M49 ^ M62; 193| 520k| uint16_t P15 = M54 ^ M59; 194| 520k| uint16_t P16 = M57 ^ M61; 195| 520k| uint16_t P17 = M58 ^ P2; 196| 520k| uint16_t P18 = M63 ^ P5; 197| 520k| uint16_t P19 = P2 ^ P3; 198| 520k| uint16_t P20 = P4 ^ P6; 199| 520k| uint16_t P22 = P2 ^ P7; 200| 520k| uint16_t P23 = P7 ^ P8; 201| 520k| uint16_t P24 = P5 ^ P7; 202| 520k| uint16_t P25 = P6 ^ P10; 203| 520k| uint16_t P26 = P9 ^ P11; 204| 520k| uint16_t P27 = P10 ^ P18; 205| 520k| uint16_t P28 = P11 ^ P25; 206| 520k| uint16_t P29 = P15 ^ P20; 207| 520k| s->slice[7] = P13 ^ P22; 208| 520k| s->slice[6] = P26 ^ P29; 209| 520k| s->slice[5] = P17 ^ P28; 210| 520k| s->slice[4] = P12 ^ P22; 211| 520k| s->slice[3] = P23 ^ P27; 212| 520k| s->slice[2] = P19 ^ P24; 213| 520k| s->slice[1] = P14 ^ P23; 214| 520k| s->slice[0] = P9 ^ P16; 215| 712k| } else { 216| | /* Linear postprocessing */ 217| 712k| uint16_t L0 = M61 ^ M62; 218| 712k| uint16_t L1 = M50 ^ M56; 219| 712k| uint16_t L2 = M46 ^ M48; 220| 712k| uint16_t L3 = M47 ^ M55; 221| 712k| uint16_t L4 = M54 ^ M58; 222| 712k| uint16_t L5 = M49 ^ M61; 223| 712k| uint16_t L6 = M62 ^ L5; 224| 712k| uint16_t L7 = M46 ^ L3; 225| 712k| uint16_t L8 = M51 ^ M59; 226| 712k| uint16_t L9 = M52 ^ M53; 227| 712k| uint16_t L10 = M53 ^ L4; 228| 712k| uint16_t L11 = M60 ^ L2; 229| 712k| uint16_t L12 = M48 ^ M51; 230| 712k| uint16_t L13 = M50 ^ L0; 231| 712k| uint16_t L14 = M52 ^ M61; 232| 712k| uint16_t L15 = M55 ^ L1; 233| 712k| uint16_t L16 = M56 ^ L0; 234| 712k| uint16_t L17 = M57 ^ L1; 235| 712k| uint16_t L18 = M58 ^ L8; 236| 712k| uint16_t L19 = M63 ^ L4; 237| 712k| uint16_t L20 = L0 ^ L1; 238| 712k| uint16_t L21 = L1 ^ L7; 239| 712k| uint16_t L22 = L3 ^ L12; 240| 712k| uint16_t L23 = L18 ^ L2; 241| 712k| uint16_t L24 = L15 ^ L9; 242| 712k| uint16_t L25 = L6 ^ L10; 243| 712k| uint16_t L26 = L7 ^ L9; 244| 712k| uint16_t L27 = L8 ^ L10; 245| 712k| uint16_t L28 = L11 ^ L14; 246| 712k| uint16_t L29 = L11 ^ L17; 247| 712k| s->slice[7] = L6 ^ L24; 248| 712k| s->slice[6] = ~(L16 ^ L26); 249| 712k| s->slice[5] = ~(L19 ^ L28); 250| 712k| s->slice[4] = L6 ^ L21; 251| 712k| s->slice[3] = L20 ^ L22; 252| 712k| s->slice[2] = L25 ^ L29; 253| 712k| s->slice[1] = ~(L13 ^ L27); 254| 712k| s->slice[0] = ~(L6 ^ L23); 255| 712k| } 256| 1.23M|} aes.cpp:_ZL17KeySetupTransformP9AES_statePKS_: 378| 141k|static void KeySetupTransform(AES_state* s, const AES_state* r) { 379| 141k| int b; 380| 1.27M| for (b = 0; b < 8; b++) { ------------------ | Branch (380:17): [True: 1.13M, False: 141k] ------------------ 381| 1.13M| s->slice[b] = ((s->slice[b] >> 4) | (s->slice[b] << 12)) ^ r->slice[b]; 382| 1.13M| } 383| 141k|} aes.cpp:_ZL5MultXP9AES_state: 386| 141k|static void MultX(AES_state* s) { 387| 141k| uint16_t top = s->slice[7]; 388| 141k| s->slice[7] = s->slice[6]; 389| 141k| s->slice[6] = s->slice[5]; 390| 141k| s->slice[5] = s->slice[4]; 391| 141k| s->slice[4] = s->slice[3] ^ top; 392| 141k| s->slice[3] = s->slice[2] ^ top; 393| 141k| s->slice[2] = s->slice[1]; 394| 141k| s->slice[1] = s->slice[0] ^ top; 395| 141k| s->slice[0] = top; 396| 141k|} aes.cpp:_ZL17KeySetupColumnMixP9AES_stateS0_PKS_ii: 370| 1.04M|static void KeySetupColumnMix(AES_state* s, AES_state* r, const AES_state* a, int c1, int c2) { 371| 1.04M| int b; 372| 9.44M| for (b = 0; b < 8; b++) { ------------------ | Branch (372:17): [True: 8.39M, False: 1.04M] ------------------ 373| 8.39M| r->slice[b] |= ((s->slice[b] ^= ((a->slice[b] >> c2) & 0x1111)) & 0x1111) << c1; 374| 8.39M| } 375| 1.04M|} aes.cpp:_ZL11AES_encryptPK9AES_stateiPhPKh: 449| 32.1k|static void AES_encrypt(const AES_state* rounds, int nrounds, unsigned char* cipher16, const unsigned char* plain16) { 450| 32.1k| AES_state s = {{0}}; 451| 32.1k| int round; 452| | 453| 32.1k| LoadBytes(&s, plain16); 454| 32.1k| AddRoundKey(&s, rounds++); 455| | 456| 450k| for (round = 1; round < nrounds; round++) { ------------------ | Branch (456:21): [True: 418k, False: 32.1k] ------------------ 457| 418k| SubBytes(&s, 0); 458| 418k| ShiftRows(&s); 459| 418k| MixColumns(&s, 0); 460| 418k| AddRoundKey(&s, rounds++); 461| 418k| } 462| | 463| 32.1k| SubBytes(&s, 0); 464| 32.1k| ShiftRows(&s); 465| 32.1k| AddRoundKey(&s, rounds); 466| | 467| 32.1k| SaveBytes(cipher16, &s); 468| 32.1k|} aes.cpp:_ZL9LoadBytesP9AES_statePKh: 34| 69.3k|static void LoadBytes(AES_state *s, const unsigned char* data16) { 35| 69.3k| int c; 36| 346k| for (c = 0; c < 4; c++) { ------------------ | Branch (36:17): [True: 277k, False: 69.3k] ------------------ 37| 277k| int r; 38| 1.38M| for (r = 0; r < 4; r++) { ------------------ | Branch (38:21): [True: 1.10M, False: 277k] ------------------ 39| 1.10M| LoadByte(s, *(data16++), r, c); 40| 1.10M| } 41| 277k| } 42| 69.3k|} aes.cpp:_ZL11AddRoundKeyP9AES_statePKS_: 354| 1.03M|static void AddRoundKey(AES_state* s, const AES_state* round) { 355| 1.03M| int b; 356| 9.35M| for (b = 0; b < 8; b++) { ------------------ | Branch (356:17): [True: 8.31M, False: 1.03M] ------------------ 357| 8.31M| s->slice[b] ^= round->slice[b]; 358| 8.31M| } 359| 1.03M|} aes.cpp:_ZL9ShiftRowsP9AES_state: 263| 450k|static void ShiftRows(AES_state* s) { 264| 450k| int i; 265| 4.05M| for (i = 0; i < 8; i++) { ------------------ | Branch (265:17): [True: 3.60M, False: 450k] ------------------ 266| 3.60M| uint16_t v = s->slice[i]; 267| 3.60M| s->slice[i] = 268| 3.60M| (v & BIT_RANGE(0, 4)) | ------------------ | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) ------------------ 269| 3.60M| BIT_RANGE_LEFT(v, 4, 5, 3) | BIT_RANGE_RIGHT(v, 5, 8, 1) | ------------------ | | 260| 3.60M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 4, 5, 3) | BIT_RANGE_RIGHT(v, 5, 8, 1) | ------------------ | | 261| 3.60M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 270| 3.60M| BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) | ------------------ | | 260| 3.60M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) | ------------------ | | 261| 3.60M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 271| 3.60M| BIT_RANGE_LEFT(v, 12, 15, 1) | BIT_RANGE_RIGHT(v, 15, 16, 3); ------------------ | | 260| 3.60M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 12, 15, 1) | BIT_RANGE_RIGHT(v, 15, 16, 3); ------------------ | | 261| 3.60M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 3.60M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 272| 3.60M| } 273| 450k|} aes.cpp:_ZL10MixColumnsP9AES_statei: 289| 901k|static void MixColumns(AES_state* s, int inv) { 290| | /* The MixColumns transform treats the bytes of the columns of the state as 291| | * coefficients of a 3rd degree polynomial over GF(2^8) and multiplies them 292| | * by the fixed polynomial a(x) = {03}x^3 + {01}x^2 + {01}x + {02}, modulo 293| | * x^4 + {01}. 294| | * 295| | * In the inverse transform, we multiply by the inverse of a(x), 296| | * a^-1(x) = {0b}x^3 + {0d}x^2 + {09}x + {0e}. This is equal to 297| | * a(x) * ({04}x^2 + {05}), so we can reuse the forward transform's code 298| | * (found in OpenSSL's bsaes-x86_64.pl, attributed to Jussi Kivilinna) 299| | * 300| | * In the bitsliced representation, a multiplication of every column by x 301| | * mod x^4 + 1 is simply a right rotation. 302| | */ 303| | 304| | /* Shared for both directions is a multiplication by a(x), which can be 305| | * rewritten as (x^3 + x^2 + x) + {02}*(x^3 + {01}). 306| | * 307| | * First compute s into the s? variables, (x^3 + {01}) * s into the s?_01 308| | * variables and (x^3 + x^2 + x)*s into the s?_123 variables. 309| | */ 310| 901k| uint16_t s0 = s->slice[0], s1 = s->slice[1], s2 = s->slice[2], s3 = s->slice[3]; 311| 901k| uint16_t s4 = s->slice[4], s5 = s->slice[5], s6 = s->slice[6], s7 = s->slice[7]; 312| 901k| uint16_t s0_01 = s0 ^ ROT(s0, 1), s0_123 = ROT(s0_01, 1) ^ ROT(s0, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s0_01 = s0 ^ ROT(s0, 1), s0_123 = ROT(s0_01, 1) ^ ROT(s0, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s0_01 = s0 ^ ROT(s0, 1), s0_123 = ROT(s0_01, 1) ^ ROT(s0, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 313| 901k| uint16_t s1_01 = s1 ^ ROT(s1, 1), s1_123 = ROT(s1_01, 1) ^ ROT(s1, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s1_01 = s1 ^ ROT(s1, 1), s1_123 = ROT(s1_01, 1) ^ ROT(s1, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s1_01 = s1 ^ ROT(s1, 1), s1_123 = ROT(s1_01, 1) ^ ROT(s1, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 314| 901k| uint16_t s2_01 = s2 ^ ROT(s2, 1), s2_123 = ROT(s2_01, 1) ^ ROT(s2, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s2_01 = s2 ^ ROT(s2, 1), s2_123 = ROT(s2_01, 1) ^ ROT(s2, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s2_01 = s2 ^ ROT(s2, 1), s2_123 = ROT(s2_01, 1) ^ ROT(s2, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 315| 901k| uint16_t s3_01 = s3 ^ ROT(s3, 1), s3_123 = ROT(s3_01, 1) ^ ROT(s3, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s3_01 = s3 ^ ROT(s3, 1), s3_123 = ROT(s3_01, 1) ^ ROT(s3, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s3_01 = s3 ^ ROT(s3, 1), s3_123 = ROT(s3_01, 1) ^ ROT(s3, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 316| 901k| uint16_t s4_01 = s4 ^ ROT(s4, 1), s4_123 = ROT(s4_01, 1) ^ ROT(s4, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s4_01 = s4 ^ ROT(s4, 1), s4_123 = ROT(s4_01, 1) ^ ROT(s4, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s4_01 = s4 ^ ROT(s4, 1), s4_123 = ROT(s4_01, 1) ^ ROT(s4, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 317| 901k| uint16_t s5_01 = s5 ^ ROT(s5, 1), s5_123 = ROT(s5_01, 1) ^ ROT(s5, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s5_01 = s5 ^ ROT(s5, 1), s5_123 = ROT(s5_01, 1) ^ ROT(s5, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s5_01 = s5 ^ ROT(s5, 1), s5_123 = ROT(s5_01, 1) ^ ROT(s5, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 318| 901k| uint16_t s6_01 = s6 ^ ROT(s6, 1), s6_123 = ROT(s6_01, 1) ^ ROT(s6, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s6_01 = s6 ^ ROT(s6, 1), s6_123 = ROT(s6_01, 1) ^ ROT(s6, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s6_01 = s6 ^ ROT(s6, 1), s6_123 = ROT(s6_01, 1) ^ ROT(s6, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 319| 901k| uint16_t s7_01 = s7 ^ ROT(s7, 1), s7_123 = ROT(s7_01, 1) ^ ROT(s7, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s7_01 = s7 ^ ROT(s7, 1), s7_123 = ROT(s7_01, 1) ^ ROT(s7, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ uint16_t s7_01 = s7 ^ ROT(s7, 1), s7_123 = ROT(s7_01, 1) ^ ROT(s7, 3); ------------------ | | 287| 901k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 320| | /* Now compute s = s?_123 + {02} * s?_01. */ 321| 901k| s->slice[0] = s7_01 ^ s0_123; 322| 901k| s->slice[1] = s7_01 ^ s0_01 ^ s1_123; 323| 901k| s->slice[2] = s1_01 ^ s2_123; 324| 901k| s->slice[3] = s7_01 ^ s2_01 ^ s3_123; 325| 901k| s->slice[4] = s7_01 ^ s3_01 ^ s4_123; 326| 901k| s->slice[5] = s4_01 ^ s5_123; 327| 901k| s->slice[6] = s5_01 ^ s6_123; 328| 901k| s->slice[7] = s6_01 ^ s7_123; 329| 901k| if (inv) { ------------------ | Branch (329:9): [True: 483k, False: 418k] ------------------ 330| | /* In the reverse direction, we further need to multiply by 331| | * {04}x^2 + {05}, which can be written as {04} * (x^2 + {01}) + {01}. 332| | * 333| | * First compute (x^2 + {01}) * s into the t?_02 variables: */ 334| 483k| uint16_t t0_02 = s->slice[0] ^ ROT(s->slice[0], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 335| 483k| uint16_t t1_02 = s->slice[1] ^ ROT(s->slice[1], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 336| 483k| uint16_t t2_02 = s->slice[2] ^ ROT(s->slice[2], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 337| 483k| uint16_t t3_02 = s->slice[3] ^ ROT(s->slice[3], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 338| 483k| uint16_t t4_02 = s->slice[4] ^ ROT(s->slice[4], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 339| 483k| uint16_t t5_02 = s->slice[5] ^ ROT(s->slice[5], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 340| 483k| uint16_t t6_02 = s->slice[6] ^ ROT(s->slice[6], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 341| 483k| uint16_t t7_02 = s->slice[7] ^ ROT(s->slice[7], 2); ------------------ | | 287| 483k|#define ROT(x,b) (((x) >> ((b) * 4)) | ((x) << ((4-(b)) * 4))) ------------------ 342| | /* And then update s += {04} * t?_02 */ 343| 483k| s->slice[0] ^= t6_02; 344| 483k| s->slice[1] ^= t6_02 ^ t7_02; 345| 483k| s->slice[2] ^= t0_02 ^ t7_02; 346| 483k| s->slice[3] ^= t1_02 ^ t6_02; 347| 483k| s->slice[4] ^= t2_02 ^ t6_02 ^ t7_02; 348| 483k| s->slice[5] ^= t3_02 ^ t7_02; 349| 483k| s->slice[6] ^= t4_02; 350| 483k| s->slice[7] ^= t5_02; 351| 483k| } 352| 901k|} aes.cpp:_ZL9SaveBytesPhPK9AES_state: 45| 69.3k|static void SaveBytes(unsigned char* data16, const AES_state *s) { 46| 69.3k| int c; 47| 346k| for (c = 0; c < 4; c++) { ------------------ | Branch (47:17): [True: 277k, False: 69.3k] ------------------ 48| 277k| int r; 49| 1.38M| for (r = 0; r < 4; r++) { ------------------ | Branch (49:21): [True: 1.10M, False: 277k] ------------------ 50| 1.10M| int b; 51| 1.10M| uint8_t v = 0; 52| 9.98M| for (b = 0; b < 8; b++) { ------------------ | Branch (52:25): [True: 8.87M, False: 1.10M] ------------------ 53| 8.87M| v |= ((s->slice[b] >> (r * 4 + c)) & 1) << b; 54| 8.87M| } 55| 1.10M| *(data16++) = v; 56| 1.10M| } 57| 277k| } 58| 69.3k|} aes.cpp:_ZL11AES_decryptPK9AES_stateiPhPKh: 470| 37.1k|static void AES_decrypt(const AES_state* rounds, int nrounds, unsigned char* plain16, const unsigned char* cipher16) { 471| | /* Most AES decryption implementations use the alternate scheme 472| | * (the Equivalent Inverse Cipher), which allows for more code reuse between 473| | * the encryption and decryption code, but requires separate setup for both. 474| | */ 475| 37.1k| AES_state s = {{0}}; 476| 37.1k| int round; 477| | 478| 37.1k| rounds += nrounds; 479| | 480| 37.1k| LoadBytes(&s, cipher16); 481| 37.1k| AddRoundKey(&s, rounds--); 482| | 483| 520k| for (round = 1; round < nrounds; round++) { ------------------ | Branch (483:21): [True: 483k, False: 37.1k] ------------------ 484| 483k| InvShiftRows(&s); 485| 483k| SubBytes(&s, 1); 486| 483k| AddRoundKey(&s, rounds--); 487| 483k| MixColumns(&s, 1); 488| 483k| } 489| | 490| 37.1k| InvShiftRows(&s); 491| 37.1k| SubBytes(&s, 1); 492| 37.1k| AddRoundKey(&s, rounds); 493| | 494| 37.1k| SaveBytes(plain16, &s); 495| 37.1k|} aes.cpp:_ZL12InvShiftRowsP9AES_state: 275| 520k|static void InvShiftRows(AES_state* s) { 276| 520k| int i; 277| 4.68M| for (i = 0; i < 8; i++) { ------------------ | Branch (277:17): [True: 4.16M, False: 520k] ------------------ 278| 4.16M| uint16_t v = s->slice[i]; 279| 4.16M| s->slice[i] = 280| 4.16M| (v & BIT_RANGE(0, 4)) | ------------------ | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) ------------------ 281| 4.16M| BIT_RANGE_LEFT(v, 4, 7, 1) | BIT_RANGE_RIGHT(v, 7, 8, 3) | ------------------ | | 260| 4.16M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 4, 7, 1) | BIT_RANGE_RIGHT(v, 7, 8, 3) | ------------------ | | 261| 4.16M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 282| 4.16M| BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) | ------------------ | | 260| 4.16M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 8, 10, 2) | BIT_RANGE_RIGHT(v, 10, 12, 2) | ------------------ | | 261| 4.16M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 283| 4.16M| BIT_RANGE_LEFT(v, 12, 13, 3) | BIT_RANGE_RIGHT(v, 13, 16, 1); ------------------ | | 260| 4.16M|#define BIT_RANGE_LEFT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) << (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ BIT_RANGE_LEFT(v, 12, 13, 3) | BIT_RANGE_RIGHT(v, 13, 16, 1); ------------------ | | 261| 4.16M|#define BIT_RANGE_RIGHT(x,from,to,shift) (((x) & BIT_RANGE((from), (to))) >> (shift)) | | ------------------ | | | | 258| 4.16M|#define BIT_RANGE(from,to) (((1 << ((to) - (from))) - 1) << (from)) | | ------------------ ------------------ 284| 4.16M| } 285| 520k|} _ZN7CSHA256C2Ev: 697| 7.36k|{ 698| 7.36k| sha256::Initialize(s); 699| 7.36k|} _ZN7CSHA2565WriteEPKhm: 702| 44.1k|{ 703| 44.1k| const unsigned char* end = data + len; 704| 44.1k| size_t bufsize = bytes % 64; 705| 44.1k| if (bufsize && bufsize + len >= 64) { ------------------ | Branch (705:9): [True: 23.1k, False: 21.0k] | Branch (705:20): [True: 14.7k, False: 8.39k] ------------------ 706| | // Fill the buffer, and process it. 707| 14.7k| memcpy(buf + bufsize, data, 64 - bufsize); 708| 14.7k| bytes += 64 - bufsize; 709| 14.7k| data += 64 - bufsize; 710| 14.7k| Transform(s, buf, 1); 711| 14.7k| bufsize = 0; 712| 14.7k| } 713| 44.1k| if (end - data >= 64) { ------------------ | Branch (713:9): [True: 568, False: 43.6k] ------------------ 714| 568| size_t blocks = (end - data) / 64; 715| 568| Transform(s, data, blocks); 716| 568| data += 64 * blocks; 717| 568| bytes += 64 * blocks; 718| 568| } 719| 44.1k| if (end > data) { ------------------ | Branch (719:9): [True: 23.1k, False: 21.0k] ------------------ 720| | // Fill the buffer with what remains. 721| 23.1k| memcpy(buf + bufsize, data, end - data); 722| 23.1k| bytes += end - data; 723| 23.1k| } 724| 44.1k| return *this; 725| 44.1k|} _ZN7CSHA2568FinalizeEPh: 728| 14.7k|{ 729| 14.7k| static const unsigned char pad[64] = {0x80}; 730| 14.7k| unsigned char sizedesc[8]; 731| 14.7k| WriteBE64(sizedesc, bytes << 3); 732| 14.7k| Write(pad, 1 + ((119 - (bytes % 64)) % 64)); 733| 14.7k| Write(sizedesc, 8); 734| 14.7k| WriteBE32(hash, s[0]); 735| 14.7k| WriteBE32(hash + 4, s[1]); 736| 14.7k| WriteBE32(hash + 8, s[2]); 737| 14.7k| WriteBE32(hash + 12, s[3]); 738| 14.7k| WriteBE32(hash + 16, s[4]); 739| 14.7k| WriteBE32(hash + 20, s[5]); 740| 14.7k| WriteBE32(hash + 24, s[6]); 741| 14.7k| WriteBE32(hash + 28, s[7]); 742| 14.7k|} _ZN7CSHA2565ResetEv: 745| 7.36k|{ 746| 7.36k| bytes = 0; 747| 7.36k| sha256::Initialize(s); 748| 7.36k| return *this; 749| 7.36k|} sha256.cpp:_ZN12_GLOBAL__N_16sha25610InitializeEPj: 89| 14.7k|{ 90| 14.7k| s[0] = 0x6a09e667ul; 91| 14.7k| s[1] = 0xbb67ae85ul; 92| 14.7k| s[2] = 0x3c6ef372ul; 93| 14.7k| s[3] = 0xa54ff53aul; 94| 14.7k| s[4] = 0x510e527ful; 95| 14.7k| s[5] = 0x9b05688cul; 96| 14.7k| s[6] = 0x1f83d9abul; 97| 14.7k| s[7] = 0x5be0cd19ul; 98| 14.7k|} _ZN11sha256_sse49TransformEPjPKhm: 23| 15.3k|{ 24| 15.3k| static const uint32_t K256 alignas(16) [] = { 25| 15.3k| 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 26| 15.3k| 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 27| 15.3k| 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 28| 15.3k| 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 29| 15.3k| 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 30| 15.3k| 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 31| 15.3k| 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 32| 15.3k| 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 33| 15.3k| 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 34| 15.3k| 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 35| 15.3k| 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 36| 15.3k| 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 37| 15.3k| 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 38| 15.3k| 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3, 39| 15.3k| 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 40| 15.3k| 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, 41| 15.3k| }; 42| 15.3k| static const uint32_t FLIP_MASK alignas(16) [] = {0x00010203, 0x04050607, 0x08090a0b, 0x0c0d0e0f}; 43| 15.3k| static const uint32_t SHUF_00BA alignas(16) [] = {0x03020100, 0x0b0a0908, 0xffffffff, 0xffffffff}; 44| 15.3k| static const uint32_t SHUF_DC00 alignas(16) [] = {0xffffffff, 0xffffffff, 0x03020100, 0x0b0a0908}; 45| 15.3k| uint32_t a, b, c, d, f, g, h, y0, y1, y2; 46| 15.3k| uint64_t tbl; 47| 15.3k| uint64_t inp_end, inp; 48| 15.3k| uint32_t xfer alignas(16) [4]; 49| | 50| 15.3k| __asm__ __volatile__( 51| 15.3k| "shl $0x6,%2;" 52| 15.3k| "je Ldone_hash_%=;" 53| 15.3k| "add %1,%2;" 54| 15.3k| "mov %2,%14;" 55| 15.3k| "mov (%0),%3;" 56| 15.3k| "mov 0x4(%0),%4;" 57| 15.3k| "mov 0x8(%0),%5;" 58| 15.3k| "mov 0xc(%0),%6;" 59| 15.3k| "mov 0x10(%0),%k2;" 60| 15.3k| "mov 0x14(%0),%7;" 61| 15.3k| "mov 0x18(%0),%8;" 62| 15.3k| "mov 0x1c(%0),%9;" 63| 15.3k| "movdqa %18,%%xmm12;" 64| 15.3k| "movdqa %19,%%xmm10;" 65| 15.3k| "movdqa %20,%%xmm11;" 66| | 67| 15.3k| "Lloop0_%=:" 68| 15.3k| "lea %17,%13;" 69| 15.3k| "movdqu (%1),%%xmm4;" 70| 15.3k| "pshufb %%xmm12,%%xmm4;" 71| 15.3k| "movdqu 0x10(%1),%%xmm5;" 72| 15.3k| "pshufb %%xmm12,%%xmm5;" 73| 15.3k| "movdqu 0x20(%1),%%xmm6;" 74| 15.3k| "pshufb %%xmm12,%%xmm6;" 75| 15.3k| "movdqu 0x30(%1),%%xmm7;" 76| 15.3k| "pshufb %%xmm12,%%xmm7;" 77| 15.3k| "mov %1,%15;" 78| 15.3k| "mov $3,%1;" 79| | 80| 15.3k| "Lloop1_%=:" 81| 15.3k| "movdqa 0x0(%13),%%xmm9;" 82| 15.3k| "paddd %%xmm4,%%xmm9;" 83| 15.3k| "movdqa %%xmm9,%16;" 84| 15.3k| "movdqa %%xmm7,%%xmm0;" 85| 15.3k| "mov %k2,%10;" 86| 15.3k| "ror $0xe,%10;" 87| 15.3k| "mov %3,%11;" 88| 15.3k| "palignr $0x4,%%xmm6,%%xmm0;" 89| 15.3k| "ror $0x9,%11;" 90| 15.3k| "xor %k2,%10;" 91| 15.3k| "mov %7,%12;" 92| 15.3k| "ror $0x5,%10;" 93| 15.3k| "movdqa %%xmm5,%%xmm1;" 94| 15.3k| "xor %3,%11;" 95| 15.3k| "xor %8,%12;" 96| 15.3k| "paddd %%xmm4,%%xmm0;" 97| 15.3k| "xor %k2,%10;" 98| 15.3k| "and %k2,%12;" 99| 15.3k| "ror $0xb,%11;" 100| 15.3k| "palignr $0x4,%%xmm4,%%xmm1;" 101| 15.3k| "xor %3,%11;" 102| 15.3k| "ror $0x6,%10;" 103| 15.3k| "xor %8,%12;" 104| 15.3k| "movdqa %%xmm1,%%xmm2;" 105| 15.3k| "ror $0x2,%11;" 106| 15.3k| "add %10,%12;" 107| 15.3k| "add %16,%12;" 108| 15.3k| "movdqa %%xmm1,%%xmm3;" 109| 15.3k| "mov %3,%10;" 110| 15.3k| "add %12,%9;" 111| 15.3k| "mov %3,%12;" 112| 15.3k| "pslld $0x19,%%xmm1;" 113| 15.3k| "or %5,%10;" 114| 15.3k| "add %9,%6;" 115| 15.3k| "and %5,%12;" 116| 15.3k| "psrld $0x7,%%xmm2;" 117| 15.3k| "and %4,%10;" 118| 15.3k| "add %11,%9;" 119| 15.3k| "por %%xmm2,%%xmm1;" 120| 15.3k| "or %12,%10;" 121| 15.3k| "add %10,%9;" 122| 15.3k| "movdqa %%xmm3,%%xmm2;" 123| 15.3k| "mov %6,%10;" 124| 15.3k| "mov %9,%11;" 125| 15.3k| "movdqa %%xmm3,%%xmm8;" 126| 15.3k| "ror $0xe,%10;" 127| 15.3k| "xor %6,%10;" 128| 15.3k| "mov %k2,%12;" 129| 15.3k| "ror $0x9,%11;" 130| 15.3k| "pslld $0xe,%%xmm3;" 131| 15.3k| "xor %9,%11;" 132| 15.3k| "ror $0x5,%10;" 133| 15.3k| "xor %7,%12;" 134| 15.3k| "psrld $0x12,%%xmm2;" 135| 15.3k| "ror $0xb,%11;" 136| 15.3k| "xor %6,%10;" 137| 15.3k| "and %6,%12;" 138| 15.3k| "ror $0x6,%10;" 139| 15.3k| "pxor %%xmm3,%%xmm1;" 140| 15.3k| "xor %9,%11;" 141| 15.3k| "xor %7,%12;" 142| 15.3k| "psrld $0x3,%%xmm8;" 143| 15.3k| "add %10,%12;" 144| 15.3k| "add 4+%16,%12;" 145| 15.3k| "ror $0x2,%11;" 146| 15.3k| "pxor %%xmm2,%%xmm1;" 147| 15.3k| "mov %9,%10;" 148| 15.3k| "add %12,%8;" 149| 15.3k| "mov %9,%12;" 150| 15.3k| "pxor %%xmm8,%%xmm1;" 151| 15.3k| "or %4,%10;" 152| 15.3k| "add %8,%5;" 153| 15.3k| "and %4,%12;" 154| 15.3k| "pshufd $0xfa,%%xmm7,%%xmm2;" 155| 15.3k| "and %3,%10;" 156| 15.3k| "add %11,%8;" 157| 15.3k| "paddd %%xmm1,%%xmm0;" 158| 15.3k| "or %12,%10;" 159| 15.3k| "add %10,%8;" 160| 15.3k| "movdqa %%xmm2,%%xmm3;" 161| 15.3k| "mov %5,%10;" 162| 15.3k| "mov %8,%11;" 163| 15.3k| "ror $0xe,%10;" 164| 15.3k| "movdqa %%xmm2,%%xmm8;" 165| 15.3k| "xor %5,%10;" 166| 15.3k| "ror $0x9,%11;" 167| 15.3k| "mov %6,%12;" 168| 15.3k| "xor %8,%11;" 169| 15.3k| "ror $0x5,%10;" 170| 15.3k| "psrlq $0x11,%%xmm2;" 171| 15.3k| "xor %k2,%12;" 172| 15.3k| "psrlq $0x13,%%xmm3;" 173| 15.3k| "xor %5,%10;" 174| 15.3k| "and %5,%12;" 175| 15.3k| "psrld $0xa,%%xmm8;" 176| 15.3k| "ror $0xb,%11;" 177| 15.3k| "xor %8,%11;" 178| 15.3k| "xor %k2,%12;" 179| 15.3k| "ror $0x6,%10;" 180| 15.3k| "pxor %%xmm3,%%xmm2;" 181| 15.3k| "add %10,%12;" 182| 15.3k| "ror $0x2,%11;" 183| 15.3k| "add 8+%16,%12;" 184| 15.3k| "pxor %%xmm2,%%xmm8;" 185| 15.3k| "mov %8,%10;" 186| 15.3k| "add %12,%7;" 187| 15.3k| "mov %8,%12;" 188| 15.3k| "pshufb %%xmm10,%%xmm8;" 189| 15.3k| "or %3,%10;" 190| 15.3k| "add %7,%4;" 191| 15.3k| "and %3,%12;" 192| 15.3k| "paddd %%xmm8,%%xmm0;" 193| 15.3k| "and %9,%10;" 194| 15.3k| "add %11,%7;" 195| 15.3k| "pshufd $0x50,%%xmm0,%%xmm2;" 196| 15.3k| "or %12,%10;" 197| 15.3k| "add %10,%7;" 198| 15.3k| "movdqa %%xmm2,%%xmm3;" 199| 15.3k| "mov %4,%10;" 200| 15.3k| "ror $0xe,%10;" 201| 15.3k| "mov %7,%11;" 202| 15.3k| "movdqa %%xmm2,%%xmm4;" 203| 15.3k| "ror $0x9,%11;" 204| 15.3k| "xor %4,%10;" 205| 15.3k| "mov %5,%12;" 206| 15.3k| "ror $0x5,%10;" 207| 15.3k| "psrlq $0x11,%%xmm2;" 208| 15.3k| "xor %7,%11;" 209| 15.3k| "xor %6,%12;" 210| 15.3k| "psrlq $0x13,%%xmm3;" 211| 15.3k| "xor %4,%10;" 212| 15.3k| "and %4,%12;" 213| 15.3k| "ror $0xb,%11;" 214| 15.3k| "psrld $0xa,%%xmm4;" 215| 15.3k| "xor %7,%11;" 216| 15.3k| "ror $0x6,%10;" 217| 15.3k| "xor %6,%12;" 218| 15.3k| "pxor %%xmm3,%%xmm2;" 219| 15.3k| "ror $0x2,%11;" 220| 15.3k| "add %10,%12;" 221| 15.3k| "add 12+%16,%12;" 222| 15.3k| "pxor %%xmm2,%%xmm4;" 223| 15.3k| "mov %7,%10;" 224| 15.3k| "add %12,%k2;" 225| 15.3k| "mov %7,%12;" 226| 15.3k| "pshufb %%xmm11,%%xmm4;" 227| 15.3k| "or %9,%10;" 228| 15.3k| "add %k2,%3;" 229| 15.3k| "and %9,%12;" 230| 15.3k| "paddd %%xmm0,%%xmm4;" 231| 15.3k| "and %8,%10;" 232| 15.3k| "add %11,%k2;" 233| 15.3k| "or %12,%10;" 234| 15.3k| "add %10,%k2;" 235| 15.3k| "movdqa 0x10(%13),%%xmm9;" 236| 15.3k| "paddd %%xmm5,%%xmm9;" 237| 15.3k| "movdqa %%xmm9,%16;" 238| 15.3k| "movdqa %%xmm4,%%xmm0;" 239| 15.3k| "mov %3,%10;" 240| 15.3k| "ror $0xe,%10;" 241| 15.3k| "mov %k2,%11;" 242| 15.3k| "palignr $0x4,%%xmm7,%%xmm0;" 243| 15.3k| "ror $0x9,%11;" 244| 15.3k| "xor %3,%10;" 245| 15.3k| "mov %4,%12;" 246| 15.3k| "ror $0x5,%10;" 247| 15.3k| "movdqa %%xmm6,%%xmm1;" 248| 15.3k| "xor %k2,%11;" 249| 15.3k| "xor %5,%12;" 250| 15.3k| "paddd %%xmm5,%%xmm0;" 251| 15.3k| "xor %3,%10;" 252| 15.3k| "and %3,%12;" 253| 15.3k| "ror $0xb,%11;" 254| 15.3k| "palignr $0x4,%%xmm5,%%xmm1;" 255| 15.3k| "xor %k2,%11;" 256| 15.3k| "ror $0x6,%10;" 257| 15.3k| "xor %5,%12;" 258| 15.3k| "movdqa %%xmm1,%%xmm2;" 259| 15.3k| "ror $0x2,%11;" 260| 15.3k| "add %10,%12;" 261| 15.3k| "add %16,%12;" 262| 15.3k| "movdqa %%xmm1,%%xmm3;" 263| 15.3k| "mov %k2,%10;" 264| 15.3k| "add %12,%6;" 265| 15.3k| "mov %k2,%12;" 266| 15.3k| "pslld $0x19,%%xmm1;" 267| 15.3k| "or %8,%10;" 268| 15.3k| "add %6,%9;" 269| 15.3k| "and %8,%12;" 270| 15.3k| "psrld $0x7,%%xmm2;" 271| 15.3k| "and %7,%10;" 272| 15.3k| "add %11,%6;" 273| 15.3k| "por %%xmm2,%%xmm1;" 274| 15.3k| "or %12,%10;" 275| 15.3k| "add %10,%6;" 276| 15.3k| "movdqa %%xmm3,%%xmm2;" 277| 15.3k| "mov %9,%10;" 278| 15.3k| "mov %6,%11;" 279| 15.3k| "movdqa %%xmm3,%%xmm8;" 280| 15.3k| "ror $0xe,%10;" 281| 15.3k| "xor %9,%10;" 282| 15.3k| "mov %3,%12;" 283| 15.3k| "ror $0x9,%11;" 284| 15.3k| "pslld $0xe,%%xmm3;" 285| 15.3k| "xor %6,%11;" 286| 15.3k| "ror $0x5,%10;" 287| 15.3k| "xor %4,%12;" 288| 15.3k| "psrld $0x12,%%xmm2;" 289| 15.3k| "ror $0xb,%11;" 290| 15.3k| "xor %9,%10;" 291| 15.3k| "and %9,%12;" 292| 15.3k| "ror $0x6,%10;" 293| 15.3k| "pxor %%xmm3,%%xmm1;" 294| 15.3k| "xor %6,%11;" 295| 15.3k| "xor %4,%12;" 296| 15.3k| "psrld $0x3,%%xmm8;" 297| 15.3k| "add %10,%12;" 298| 15.3k| "add 4+%16,%12;" 299| 15.3k| "ror $0x2,%11;" 300| 15.3k| "pxor %%xmm2,%%xmm1;" 301| 15.3k| "mov %6,%10;" 302| 15.3k| "add %12,%5;" 303| 15.3k| "mov %6,%12;" 304| 15.3k| "pxor %%xmm8,%%xmm1;" 305| 15.3k| "or %7,%10;" 306| 15.3k| "add %5,%8;" 307| 15.3k| "and %7,%12;" 308| 15.3k| "pshufd $0xfa,%%xmm4,%%xmm2;" 309| 15.3k| "and %k2,%10;" 310| 15.3k| "add %11,%5;" 311| 15.3k| "paddd %%xmm1,%%xmm0;" 312| 15.3k| "or %12,%10;" 313| 15.3k| "add %10,%5;" 314| 15.3k| "movdqa %%xmm2,%%xmm3;" 315| 15.3k| "mov %8,%10;" 316| 15.3k| "mov %5,%11;" 317| 15.3k| "ror $0xe,%10;" 318| 15.3k| "movdqa %%xmm2,%%xmm8;" 319| 15.3k| "xor %8,%10;" 320| 15.3k| "ror $0x9,%11;" 321| 15.3k| "mov %9,%12;" 322| 15.3k| "xor %5,%11;" 323| 15.3k| "ror $0x5,%10;" 324| 15.3k| "psrlq $0x11,%%xmm2;" 325| 15.3k| "xor %3,%12;" 326| 15.3k| "psrlq $0x13,%%xmm3;" 327| 15.3k| "xor %8,%10;" 328| 15.3k| "and %8,%12;" 329| 15.3k| "psrld $0xa,%%xmm8;" 330| 15.3k| "ror $0xb,%11;" 331| 15.3k| "xor %5,%11;" 332| 15.3k| "xor %3,%12;" 333| 15.3k| "ror $0x6,%10;" 334| 15.3k| "pxor %%xmm3,%%xmm2;" 335| 15.3k| "add %10,%12;" 336| 15.3k| "ror $0x2,%11;" 337| 15.3k| "add 8+%16,%12;" 338| 15.3k| "pxor %%xmm2,%%xmm8;" 339| 15.3k| "mov %5,%10;" 340| 15.3k| "add %12,%4;" 341| 15.3k| "mov %5,%12;" 342| 15.3k| "pshufb %%xmm10,%%xmm8;" 343| 15.3k| "or %k2,%10;" 344| 15.3k| "add %4,%7;" 345| 15.3k| "and %k2,%12;" 346| 15.3k| "paddd %%xmm8,%%xmm0;" 347| 15.3k| "and %6,%10;" 348| 15.3k| "add %11,%4;" 349| 15.3k| "pshufd $0x50,%%xmm0,%%xmm2;" 350| 15.3k| "or %12,%10;" 351| 15.3k| "add %10,%4;" 352| 15.3k| "movdqa %%xmm2,%%xmm3;" 353| 15.3k| "mov %7,%10;" 354| 15.3k| "ror $0xe,%10;" 355| 15.3k| "mov %4,%11;" 356| 15.3k| "movdqa %%xmm2,%%xmm5;" 357| 15.3k| "ror $0x9,%11;" 358| 15.3k| "xor %7,%10;" 359| 15.3k| "mov %8,%12;" 360| 15.3k| "ror $0x5,%10;" 361| 15.3k| "psrlq $0x11,%%xmm2;" 362| 15.3k| "xor %4,%11;" 363| 15.3k| "xor %9,%12;" 364| 15.3k| "psrlq $0x13,%%xmm3;" 365| 15.3k| "xor %7,%10;" 366| 15.3k| "and %7,%12;" 367| 15.3k| "ror $0xb,%11;" 368| 15.3k| "psrld $0xa,%%xmm5;" 369| 15.3k| "xor %4,%11;" 370| 15.3k| "ror $0x6,%10;" 371| 15.3k| "xor %9,%12;" 372| 15.3k| "pxor %%xmm3,%%xmm2;" 373| 15.3k| "ror $0x2,%11;" 374| 15.3k| "add %10,%12;" 375| 15.3k| "add 12+%16,%12;" 376| 15.3k| "pxor %%xmm2,%%xmm5;" 377| 15.3k| "mov %4,%10;" 378| 15.3k| "add %12,%3;" 379| 15.3k| "mov %4,%12;" 380| 15.3k| "pshufb %%xmm11,%%xmm5;" 381| 15.3k| "or %6,%10;" 382| 15.3k| "add %3,%k2;" 383| 15.3k| "and %6,%12;" 384| 15.3k| "paddd %%xmm0,%%xmm5;" 385| 15.3k| "and %5,%10;" 386| 15.3k| "add %11,%3;" 387| 15.3k| "or %12,%10;" 388| 15.3k| "add %10,%3;" 389| 15.3k| "movdqa 0x20(%13),%%xmm9;" 390| 15.3k| "paddd %%xmm6,%%xmm9;" 391| 15.3k| "movdqa %%xmm9,%16;" 392| 15.3k| "movdqa %%xmm5,%%xmm0;" 393| 15.3k| "mov %k2,%10;" 394| 15.3k| "ror $0xe,%10;" 395| 15.3k| "mov %3,%11;" 396| 15.3k| "palignr $0x4,%%xmm4,%%xmm0;" 397| 15.3k| "ror $0x9,%11;" 398| 15.3k| "xor %k2,%10;" 399| 15.3k| "mov %7,%12;" 400| 15.3k| "ror $0x5,%10;" 401| 15.3k| "movdqa %%xmm7,%%xmm1;" 402| 15.3k| "xor %3,%11;" 403| 15.3k| "xor %8,%12;" 404| 15.3k| "paddd %%xmm6,%%xmm0;" 405| 15.3k| "xor %k2,%10;" 406| 15.3k| "and %k2,%12;" 407| 15.3k| "ror $0xb,%11;" 408| 15.3k| "palignr $0x4,%%xmm6,%%xmm1;" 409| 15.3k| "xor %3,%11;" 410| 15.3k| "ror $0x6,%10;" 411| 15.3k| "xor %8,%12;" 412| 15.3k| "movdqa %%xmm1,%%xmm2;" 413| 15.3k| "ror $0x2,%11;" 414| 15.3k| "add %10,%12;" 415| 15.3k| "add %16,%12;" 416| 15.3k| "movdqa %%xmm1,%%xmm3;" 417| 15.3k| "mov %3,%10;" 418| 15.3k| "add %12,%9;" 419| 15.3k| "mov %3,%12;" 420| 15.3k| "pslld $0x19,%%xmm1;" 421| 15.3k| "or %5,%10;" 422| 15.3k| "add %9,%6;" 423| 15.3k| "and %5,%12;" 424| 15.3k| "psrld $0x7,%%xmm2;" 425| 15.3k| "and %4,%10;" 426| 15.3k| "add %11,%9;" 427| 15.3k| "por %%xmm2,%%xmm1;" 428| 15.3k| "or %12,%10;" 429| 15.3k| "add %10,%9;" 430| 15.3k| "movdqa %%xmm3,%%xmm2;" 431| 15.3k| "mov %6,%10;" 432| 15.3k| "mov %9,%11;" 433| 15.3k| "movdqa %%xmm3,%%xmm8;" 434| 15.3k| "ror $0xe,%10;" 435| 15.3k| "xor %6,%10;" 436| 15.3k| "mov %k2,%12;" 437| 15.3k| "ror $0x9,%11;" 438| 15.3k| "pslld $0xe,%%xmm3;" 439| 15.3k| "xor %9,%11;" 440| 15.3k| "ror $0x5,%10;" 441| 15.3k| "xor %7,%12;" 442| 15.3k| "psrld $0x12,%%xmm2;" 443| 15.3k| "ror $0xb,%11;" 444| 15.3k| "xor %6,%10;" 445| 15.3k| "and %6,%12;" 446| 15.3k| "ror $0x6,%10;" 447| 15.3k| "pxor %%xmm3,%%xmm1;" 448| 15.3k| "xor %9,%11;" 449| 15.3k| "xor %7,%12;" 450| 15.3k| "psrld $0x3,%%xmm8;" 451| 15.3k| "add %10,%12;" 452| 15.3k| "add 4+%16,%12;" 453| 15.3k| "ror $0x2,%11;" 454| 15.3k| "pxor %%xmm2,%%xmm1;" 455| 15.3k| "mov %9,%10;" 456| 15.3k| "add %12,%8;" 457| 15.3k| "mov %9,%12;" 458| 15.3k| "pxor %%xmm8,%%xmm1;" 459| 15.3k| "or %4,%10;" 460| 15.3k| "add %8,%5;" 461| 15.3k| "and %4,%12;" 462| 15.3k| "pshufd $0xfa,%%xmm5,%%xmm2;" 463| 15.3k| "and %3,%10;" 464| 15.3k| "add %11,%8;" 465| 15.3k| "paddd %%xmm1,%%xmm0;" 466| 15.3k| "or %12,%10;" 467| 15.3k| "add %10,%8;" 468| 15.3k| "movdqa %%xmm2,%%xmm3;" 469| 15.3k| "mov %5,%10;" 470| 15.3k| "mov %8,%11;" 471| 15.3k| "ror $0xe,%10;" 472| 15.3k| "movdqa %%xmm2,%%xmm8;" 473| 15.3k| "xor %5,%10;" 474| 15.3k| "ror $0x9,%11;" 475| 15.3k| "mov %6,%12;" 476| 15.3k| "xor %8,%11;" 477| 15.3k| "ror $0x5,%10;" 478| 15.3k| "psrlq $0x11,%%xmm2;" 479| 15.3k| "xor %k2,%12;" 480| 15.3k| "psrlq $0x13,%%xmm3;" 481| 15.3k| "xor %5,%10;" 482| 15.3k| "and %5,%12;" 483| 15.3k| "psrld $0xa,%%xmm8;" 484| 15.3k| "ror $0xb,%11;" 485| 15.3k| "xor %8,%11;" 486| 15.3k| "xor %k2,%12;" 487| 15.3k| "ror $0x6,%10;" 488| 15.3k| "pxor %%xmm3,%%xmm2;" 489| 15.3k| "add %10,%12;" 490| 15.3k| "ror $0x2,%11;" 491| 15.3k| "add 8+%16,%12;" 492| 15.3k| "pxor %%xmm2,%%xmm8;" 493| 15.3k| "mov %8,%10;" 494| 15.3k| "add %12,%7;" 495| 15.3k| "mov %8,%12;" 496| 15.3k| "pshufb %%xmm10,%%xmm8;" 497| 15.3k| "or %3,%10;" 498| 15.3k| "add %7,%4;" 499| 15.3k| "and %3,%12;" 500| 15.3k| "paddd %%xmm8,%%xmm0;" 501| 15.3k| "and %9,%10;" 502| 15.3k| "add %11,%7;" 503| 15.3k| "pshufd $0x50,%%xmm0,%%xmm2;" 504| 15.3k| "or %12,%10;" 505| 15.3k| "add %10,%7;" 506| 15.3k| "movdqa %%xmm2,%%xmm3;" 507| 15.3k| "mov %4,%10;" 508| 15.3k| "ror $0xe,%10;" 509| 15.3k| "mov %7,%11;" 510| 15.3k| "movdqa %%xmm2,%%xmm6;" 511| 15.3k| "ror $0x9,%11;" 512| 15.3k| "xor %4,%10;" 513| 15.3k| "mov %5,%12;" 514| 15.3k| "ror $0x5,%10;" 515| 15.3k| "psrlq $0x11,%%xmm2;" 516| 15.3k| "xor %7,%11;" 517| 15.3k| "xor %6,%12;" 518| 15.3k| "psrlq $0x13,%%xmm3;" 519| 15.3k| "xor %4,%10;" 520| 15.3k| "and %4,%12;" 521| 15.3k| "ror $0xb,%11;" 522| 15.3k| "psrld $0xa,%%xmm6;" 523| 15.3k| "xor %7,%11;" 524| 15.3k| "ror $0x6,%10;" 525| 15.3k| "xor %6,%12;" 526| 15.3k| "pxor %%xmm3,%%xmm2;" 527| 15.3k| "ror $0x2,%11;" 528| 15.3k| "add %10,%12;" 529| 15.3k| "add 12+%16,%12;" 530| 15.3k| "pxor %%xmm2,%%xmm6;" 531| 15.3k| "mov %7,%10;" 532| 15.3k| "add %12,%k2;" 533| 15.3k| "mov %7,%12;" 534| 15.3k| "pshufb %%xmm11,%%xmm6;" 535| 15.3k| "or %9,%10;" 536| 15.3k| "add %k2,%3;" 537| 15.3k| "and %9,%12;" 538| 15.3k| "paddd %%xmm0,%%xmm6;" 539| 15.3k| "and %8,%10;" 540| 15.3k| "add %11,%k2;" 541| 15.3k| "or %12,%10;" 542| 15.3k| "add %10,%k2;" 543| 15.3k| "movdqa 0x30(%13),%%xmm9;" 544| 15.3k| "paddd %%xmm7,%%xmm9;" 545| 15.3k| "movdqa %%xmm9,%16;" 546| 15.3k| "add $0x40,%13;" 547| 15.3k| "movdqa %%xmm6,%%xmm0;" 548| 15.3k| "mov %3,%10;" 549| 15.3k| "ror $0xe,%10;" 550| 15.3k| "mov %k2,%11;" 551| 15.3k| "palignr $0x4,%%xmm5,%%xmm0;" 552| 15.3k| "ror $0x9,%11;" 553| 15.3k| "xor %3,%10;" 554| 15.3k| "mov %4,%12;" 555| 15.3k| "ror $0x5,%10;" 556| 15.3k| "movdqa %%xmm4,%%xmm1;" 557| 15.3k| "xor %k2,%11;" 558| 15.3k| "xor %5,%12;" 559| 15.3k| "paddd %%xmm7,%%xmm0;" 560| 15.3k| "xor %3,%10;" 561| 15.3k| "and %3,%12;" 562| 15.3k| "ror $0xb,%11;" 563| 15.3k| "palignr $0x4,%%xmm7,%%xmm1;" 564| 15.3k| "xor %k2,%11;" 565| 15.3k| "ror $0x6,%10;" 566| 15.3k| "xor %5,%12;" 567| 15.3k| "movdqa %%xmm1,%%xmm2;" 568| 15.3k| "ror $0x2,%11;" 569| 15.3k| "add %10,%12;" 570| 15.3k| "add %16,%12;" 571| 15.3k| "movdqa %%xmm1,%%xmm3;" 572| 15.3k| "mov %k2,%10;" 573| 15.3k| "add %12,%6;" 574| 15.3k| "mov %k2,%12;" 575| 15.3k| "pslld $0x19,%%xmm1;" 576| 15.3k| "or %8,%10;" 577| 15.3k| "add %6,%9;" 578| 15.3k| "and %8,%12;" 579| 15.3k| "psrld $0x7,%%xmm2;" 580| 15.3k| "and %7,%10;" 581| 15.3k| "add %11,%6;" 582| 15.3k| "por %%xmm2,%%xmm1;" 583| 15.3k| "or %12,%10;" 584| 15.3k| "add %10,%6;" 585| 15.3k| "movdqa %%xmm3,%%xmm2;" 586| 15.3k| "mov %9,%10;" 587| 15.3k| "mov %6,%11;" 588| 15.3k| "movdqa %%xmm3,%%xmm8;" 589| 15.3k| "ror $0xe,%10;" 590| 15.3k| "xor %9,%10;" 591| 15.3k| "mov %3,%12;" 592| 15.3k| "ror $0x9,%11;" 593| 15.3k| "pslld $0xe,%%xmm3;" 594| 15.3k| "xor %6,%11;" 595| 15.3k| "ror $0x5,%10;" 596| 15.3k| "xor %4,%12;" 597| 15.3k| "psrld $0x12,%%xmm2;" 598| 15.3k| "ror $0xb,%11;" 599| 15.3k| "xor %9,%10;" 600| 15.3k| "and %9,%12;" 601| 15.3k| "ror $0x6,%10;" 602| 15.3k| "pxor %%xmm3,%%xmm1;" 603| 15.3k| "xor %6,%11;" 604| 15.3k| "xor %4,%12;" 605| 15.3k| "psrld $0x3,%%xmm8;" 606| 15.3k| "add %10,%12;" 607| 15.3k| "add 4+%16,%12;" 608| 15.3k| "ror $0x2,%11;" 609| 15.3k| "pxor %%xmm2,%%xmm1;" 610| 15.3k| "mov %6,%10;" 611| 15.3k| "add %12,%5;" 612| 15.3k| "mov %6,%12;" 613| 15.3k| "pxor %%xmm8,%%xmm1;" 614| 15.3k| "or %7,%10;" 615| 15.3k| "add %5,%8;" 616| 15.3k| "and %7,%12;" 617| 15.3k| "pshufd $0xfa,%%xmm6,%%xmm2;" 618| 15.3k| "and %k2,%10;" 619| 15.3k| "add %11,%5;" 620| 15.3k| "paddd %%xmm1,%%xmm0;" 621| 15.3k| "or %12,%10;" 622| 15.3k| "add %10,%5;" 623| 15.3k| "movdqa %%xmm2,%%xmm3;" 624| 15.3k| "mov %8,%10;" 625| 15.3k| "mov %5,%11;" 626| 15.3k| "ror $0xe,%10;" 627| 15.3k| "movdqa %%xmm2,%%xmm8;" 628| 15.3k| "xor %8,%10;" 629| 15.3k| "ror $0x9,%11;" 630| 15.3k| "mov %9,%12;" 631| 15.3k| "xor %5,%11;" 632| 15.3k| "ror $0x5,%10;" 633| 15.3k| "psrlq $0x11,%%xmm2;" 634| 15.3k| "xor %3,%12;" 635| 15.3k| "psrlq $0x13,%%xmm3;" 636| 15.3k| "xor %8,%10;" 637| 15.3k| "and %8,%12;" 638| 15.3k| "psrld $0xa,%%xmm8;" 639| 15.3k| "ror $0xb,%11;" 640| 15.3k| "xor %5,%11;" 641| 15.3k| "xor %3,%12;" 642| 15.3k| "ror $0x6,%10;" 643| 15.3k| "pxor %%xmm3,%%xmm2;" 644| 15.3k| "add %10,%12;" 645| 15.3k| "ror $0x2,%11;" 646| 15.3k| "add 8+%16,%12;" 647| 15.3k| "pxor %%xmm2,%%xmm8;" 648| 15.3k| "mov %5,%10;" 649| 15.3k| "add %12,%4;" 650| 15.3k| "mov %5,%12;" 651| 15.3k| "pshufb %%xmm10,%%xmm8;" 652| 15.3k| "or %k2,%10;" 653| 15.3k| "add %4,%7;" 654| 15.3k| "and %k2,%12;" 655| 15.3k| "paddd %%xmm8,%%xmm0;" 656| 15.3k| "and %6,%10;" 657| 15.3k| "add %11,%4;" 658| 15.3k| "pshufd $0x50,%%xmm0,%%xmm2;" 659| 15.3k| "or %12,%10;" 660| 15.3k| "add %10,%4;" 661| 15.3k| "movdqa %%xmm2,%%xmm3;" 662| 15.3k| "mov %7,%10;" 663| 15.3k| "ror $0xe,%10;" 664| 15.3k| "mov %4,%11;" 665| 15.3k| "movdqa %%xmm2,%%xmm7;" 666| 15.3k| "ror $0x9,%11;" 667| 15.3k| "xor %7,%10;" 668| 15.3k| "mov %8,%12;" 669| 15.3k| "ror $0x5,%10;" 670| 15.3k| "psrlq $0x11,%%xmm2;" 671| 15.3k| "xor %4,%11;" 672| 15.3k| "xor %9,%12;" 673| 15.3k| "psrlq $0x13,%%xmm3;" 674| 15.3k| "xor %7,%10;" 675| 15.3k| "and %7,%12;" 676| 15.3k| "ror $0xb,%11;" 677| 15.3k| "psrld $0xa,%%xmm7;" 678| 15.3k| "xor %4,%11;" 679| 15.3k| "ror $0x6,%10;" 680| 15.3k| "xor %9,%12;" 681| 15.3k| "pxor %%xmm3,%%xmm2;" 682| 15.3k| "ror $0x2,%11;" 683| 15.3k| "add %10,%12;" 684| 15.3k| "add 12+%16,%12;" 685| 15.3k| "pxor %%xmm2,%%xmm7;" 686| 15.3k| "mov %4,%10;" 687| 15.3k| "add %12,%3;" 688| 15.3k| "mov %4,%12;" 689| 15.3k| "pshufb %%xmm11,%%xmm7;" 690| 15.3k| "or %6,%10;" 691| 15.3k| "add %3,%k2;" 692| 15.3k| "and %6,%12;" 693| 15.3k| "paddd %%xmm0,%%xmm7;" 694| 15.3k| "and %5,%10;" 695| 15.3k| "add %11,%3;" 696| 15.3k| "or %12,%10;" 697| 15.3k| "add %10,%3;" 698| 15.3k| "sub $0x1,%1;" 699| 15.3k| "jne Lloop1_%=;" 700| 15.3k| "mov $0x2,%1;" 701| | 702| 15.3k| "Lloop2_%=:" 703| 15.3k| "paddd 0x0(%13),%%xmm4;" 704| 15.3k| "movdqa %%xmm4,%16;" 705| 15.3k| "mov %k2,%10;" 706| 15.3k| "ror $0xe,%10;" 707| 15.3k| "mov %3,%11;" 708| 15.3k| "xor %k2,%10;" 709| 15.3k| "ror $0x9,%11;" 710| 15.3k| "mov %7,%12;" 711| 15.3k| "xor %3,%11;" 712| 15.3k| "ror $0x5,%10;" 713| 15.3k| "xor %8,%12;" 714| 15.3k| "xor %k2,%10;" 715| 15.3k| "ror $0xb,%11;" 716| 15.3k| "and %k2,%12;" 717| 15.3k| "xor %3,%11;" 718| 15.3k| "ror $0x6,%10;" 719| 15.3k| "xor %8,%12;" 720| 15.3k| "add %10,%12;" 721| 15.3k| "ror $0x2,%11;" 722| 15.3k| "add %16,%12;" 723| 15.3k| "mov %3,%10;" 724| 15.3k| "add %12,%9;" 725| 15.3k| "mov %3,%12;" 726| 15.3k| "or %5,%10;" 727| 15.3k| "add %9,%6;" 728| 15.3k| "and %5,%12;" 729| 15.3k| "and %4,%10;" 730| 15.3k| "add %11,%9;" 731| 15.3k| "or %12,%10;" 732| 15.3k| "add %10,%9;" 733| 15.3k| "mov %6,%10;" 734| 15.3k| "ror $0xe,%10;" 735| 15.3k| "mov %9,%11;" 736| 15.3k| "xor %6,%10;" 737| 15.3k| "ror $0x9,%11;" 738| 15.3k| "mov %k2,%12;" 739| 15.3k| "xor %9,%11;" 740| 15.3k| "ror $0x5,%10;" 741| 15.3k| "xor %7,%12;" 742| 15.3k| "xor %6,%10;" 743| 15.3k| "ror $0xb,%11;" 744| 15.3k| "and %6,%12;" 745| 15.3k| "xor %9,%11;" 746| 15.3k| "ror $0x6,%10;" 747| 15.3k| "xor %7,%12;" 748| 15.3k| "add %10,%12;" 749| 15.3k| "ror $0x2,%11;" 750| 15.3k| "add 4+%16,%12;" 751| 15.3k| "mov %9,%10;" 752| 15.3k| "add %12,%8;" 753| 15.3k| "mov %9,%12;" 754| 15.3k| "or %4,%10;" 755| 15.3k| "add %8,%5;" 756| 15.3k| "and %4,%12;" 757| 15.3k| "and %3,%10;" 758| 15.3k| "add %11,%8;" 759| 15.3k| "or %12,%10;" 760| 15.3k| "add %10,%8;" 761| 15.3k| "mov %5,%10;" 762| 15.3k| "ror $0xe,%10;" 763| 15.3k| "mov %8,%11;" 764| 15.3k| "xor %5,%10;" 765| 15.3k| "ror $0x9,%11;" 766| 15.3k| "mov %6,%12;" 767| 15.3k| "xor %8,%11;" 768| 15.3k| "ror $0x5,%10;" 769| 15.3k| "xor %k2,%12;" 770| 15.3k| "xor %5,%10;" 771| 15.3k| "ror $0xb,%11;" 772| 15.3k| "and %5,%12;" 773| 15.3k| "xor %8,%11;" 774| 15.3k| "ror $0x6,%10;" 775| 15.3k| "xor %k2,%12;" 776| 15.3k| "add %10,%12;" 777| 15.3k| "ror $0x2,%11;" 778| 15.3k| "add 8+%16,%12;" 779| 15.3k| "mov %8,%10;" 780| 15.3k| "add %12,%7;" 781| 15.3k| "mov %8,%12;" 782| 15.3k| "or %3,%10;" 783| 15.3k| "add %7,%4;" 784| 15.3k| "and %3,%12;" 785| 15.3k| "and %9,%10;" 786| 15.3k| "add %11,%7;" 787| 15.3k| "or %12,%10;" 788| 15.3k| "add %10,%7;" 789| 15.3k| "mov %4,%10;" 790| 15.3k| "ror $0xe,%10;" 791| 15.3k| "mov %7,%11;" 792| 15.3k| "xor %4,%10;" 793| 15.3k| "ror $0x9,%11;" 794| 15.3k| "mov %5,%12;" 795| 15.3k| "xor %7,%11;" 796| 15.3k| "ror $0x5,%10;" 797| 15.3k| "xor %6,%12;" 798| 15.3k| "xor %4,%10;" 799| 15.3k| "ror $0xb,%11;" 800| 15.3k| "and %4,%12;" 801| 15.3k| "xor %7,%11;" 802| 15.3k| "ror $0x6,%10;" 803| 15.3k| "xor %6,%12;" 804| 15.3k| "add %10,%12;" 805| 15.3k| "ror $0x2,%11;" 806| 15.3k| "add 12+%16,%12;" 807| 15.3k| "mov %7,%10;" 808| 15.3k| "add %12,%k2;" 809| 15.3k| "mov %7,%12;" 810| 15.3k| "or %9,%10;" 811| 15.3k| "add %k2,%3;" 812| 15.3k| "and %9,%12;" 813| 15.3k| "and %8,%10;" 814| 15.3k| "add %11,%k2;" 815| 15.3k| "or %12,%10;" 816| 15.3k| "add %10,%k2;" 817| 15.3k| "paddd 0x10(%13),%%xmm5;" 818| 15.3k| "movdqa %%xmm5,%16;" 819| 15.3k| "add $0x20,%13;" 820| 15.3k| "mov %3,%10;" 821| 15.3k| "ror $0xe,%10;" 822| 15.3k| "mov %k2,%11;" 823| 15.3k| "xor %3,%10;" 824| 15.3k| "ror $0x9,%11;" 825| 15.3k| "mov %4,%12;" 826| 15.3k| "xor %k2,%11;" 827| 15.3k| "ror $0x5,%10;" 828| 15.3k| "xor %5,%12;" 829| 15.3k| "xor %3,%10;" 830| 15.3k| "ror $0xb,%11;" 831| 15.3k| "and %3,%12;" 832| 15.3k| "xor %k2,%11;" 833| 15.3k| "ror $0x6,%10;" 834| 15.3k| "xor %5,%12;" 835| 15.3k| "add %10,%12;" 836| 15.3k| "ror $0x2,%11;" 837| 15.3k| "add %16,%12;" 838| 15.3k| "mov %k2,%10;" 839| 15.3k| "add %12,%6;" 840| 15.3k| "mov %k2,%12;" 841| 15.3k| "or %8,%10;" 842| 15.3k| "add %6,%9;" 843| 15.3k| "and %8,%12;" 844| 15.3k| "and %7,%10;" 845| 15.3k| "add %11,%6;" 846| 15.3k| "or %12,%10;" 847| 15.3k| "add %10,%6;" 848| 15.3k| "mov %9,%10;" 849| 15.3k| "ror $0xe,%10;" 850| 15.3k| "mov %6,%11;" 851| 15.3k| "xor %9,%10;" 852| 15.3k| "ror $0x9,%11;" 853| 15.3k| "mov %3,%12;" 854| 15.3k| "xor %6,%11;" 855| 15.3k| "ror $0x5,%10;" 856| 15.3k| "xor %4,%12;" 857| 15.3k| "xor %9,%10;" 858| 15.3k| "ror $0xb,%11;" 859| 15.3k| "and %9,%12;" 860| 15.3k| "xor %6,%11;" 861| 15.3k| "ror $0x6,%10;" 862| 15.3k| "xor %4,%12;" 863| 15.3k| "add %10,%12;" 864| 15.3k| "ror $0x2,%11;" 865| 15.3k| "add 4+%16,%12;" 866| 15.3k| "mov %6,%10;" 867| 15.3k| "add %12,%5;" 868| 15.3k| "mov %6,%12;" 869| 15.3k| "or %7,%10;" 870| 15.3k| "add %5,%8;" 871| 15.3k| "and %7,%12;" 872| 15.3k| "and %k2,%10;" 873| 15.3k| "add %11,%5;" 874| 15.3k| "or %12,%10;" 875| 15.3k| "add %10,%5;" 876| 15.3k| "mov %8,%10;" 877| 15.3k| "ror $0xe,%10;" 878| 15.3k| "mov %5,%11;" 879| 15.3k| "xor %8,%10;" 880| 15.3k| "ror $0x9,%11;" 881| 15.3k| "mov %9,%12;" 882| 15.3k| "xor %5,%11;" 883| 15.3k| "ror $0x5,%10;" 884| 15.3k| "xor %3,%12;" 885| 15.3k| "xor %8,%10;" 886| 15.3k| "ror $0xb,%11;" 887| 15.3k| "and %8,%12;" 888| 15.3k| "xor %5,%11;" 889| 15.3k| "ror $0x6,%10;" 890| 15.3k| "xor %3,%12;" 891| 15.3k| "add %10,%12;" 892| 15.3k| "ror $0x2,%11;" 893| 15.3k| "add 8+%16,%12;" 894| 15.3k| "mov %5,%10;" 895| 15.3k| "add %12,%4;" 896| 15.3k| "mov %5,%12;" 897| 15.3k| "or %k2,%10;" 898| 15.3k| "add %4,%7;" 899| 15.3k| "and %k2,%12;" 900| 15.3k| "and %6,%10;" 901| 15.3k| "add %11,%4;" 902| 15.3k| "or %12,%10;" 903| 15.3k| "add %10,%4;" 904| 15.3k| "mov %7,%10;" 905| 15.3k| "ror $0xe,%10;" 906| 15.3k| "mov %4,%11;" 907| 15.3k| "xor %7,%10;" 908| 15.3k| "ror $0x9,%11;" 909| 15.3k| "mov %8,%12;" 910| 15.3k| "xor %4,%11;" 911| 15.3k| "ror $0x5,%10;" 912| 15.3k| "xor %9,%12;" 913| 15.3k| "xor %7,%10;" 914| 15.3k| "ror $0xb,%11;" 915| 15.3k| "and %7,%12;" 916| 15.3k| "xor %4,%11;" 917| 15.3k| "ror $0x6,%10;" 918| 15.3k| "xor %9,%12;" 919| 15.3k| "add %10,%12;" 920| 15.3k| "ror $0x2,%11;" 921| 15.3k| "add 12+%16,%12;" 922| 15.3k| "mov %4,%10;" 923| 15.3k| "add %12,%3;" 924| 15.3k| "mov %4,%12;" 925| 15.3k| "or %6,%10;" 926| 15.3k| "add %3,%k2;" 927| 15.3k| "and %6,%12;" 928| 15.3k| "and %5,%10;" 929| 15.3k| "add %11,%3;" 930| 15.3k| "or %12,%10;" 931| 15.3k| "add %10,%3;" 932| 15.3k| "movdqa %%xmm6,%%xmm4;" 933| 15.3k| "movdqa %%xmm7,%%xmm5;" 934| 15.3k| "sub $0x1,%1;" 935| 15.3k| "jne Lloop2_%=;" 936| 15.3k| "add (%0),%3;" 937| 15.3k| "mov %3,(%0);" 938| 15.3k| "add 0x4(%0),%4;" 939| 15.3k| "mov %4,0x4(%0);" 940| 15.3k| "add 0x8(%0),%5;" 941| 15.3k| "mov %5,0x8(%0);" 942| 15.3k| "add 0xc(%0),%6;" 943| 15.3k| "mov %6,0xc(%0);" 944| 15.3k| "add 0x10(%0),%k2;" 945| 15.3k| "mov %k2,0x10(%0);" 946| 15.3k| "add 0x14(%0),%7;" 947| 15.3k| "mov %7,0x14(%0);" 948| 15.3k| "add 0x18(%0),%8;" 949| 15.3k| "mov %8,0x18(%0);" 950| 15.3k| "add 0x1c(%0),%9;" 951| 15.3k| "mov %9,0x1c(%0);" 952| 15.3k| "mov %15,%1;" 953| 15.3k| "add $0x40,%1;" 954| 15.3k| "cmp %14,%1;" 955| 15.3k| "jne Lloop0_%=;" 956| | 957| 15.3k| "Ldone_hash_%=:" 958| | 959| 15.3k| : "+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| 15.3k| : "m"(K256), "m"(FLIP_MASK), "m"(SHUF_00BA), "m"(SHUF_DC00) 961| 15.3k| : "cc", "memory", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", "xmm8", "xmm9", "xmm10", "xmm11", "xmm12" 962| 15.3k| ); 963| 15.3k|} _ZN7CSHA512C2Ev: 155| 859|{ 156| 859| sha512::Initialize(s); 157| 859|} _ZN7CSHA5125WriteEPKhm: 160| 40.8M|{ 161| 40.8M| const unsigned char* end = data + len; 162| 40.8M| size_t bufsize = bytes % 128; 163| 40.8M| if (bufsize && bufsize + len >= 128) { ------------------ | Branch (163:9): [True: 27.2M, False: 13.6M] | Branch (163:20): [True: 13.6M, False: 13.6M] ------------------ 164| | // Fill the buffer, and process it. 165| 13.6M| memcpy(buf + bufsize, data, 128 - bufsize); 166| 13.6M| bytes += 128 - bufsize; 167| 13.6M| data += 128 - bufsize; 168| 13.6M| sha512::Transform(s, buf); 169| 13.6M| bufsize = 0; 170| 13.6M| } 171| 40.8M| while (end - data >= 128) { ------------------ | Branch (171:12): [True: 0, False: 40.8M] ------------------ 172| | // Process full chunks directly from the source. 173| 0| sha512::Transform(s, data); 174| 0| data += 128; 175| 0| bytes += 128; 176| 0| } 177| 40.8M| if (end > data) { ------------------ | Branch (177:9): [True: 27.2M, False: 13.6M] ------------------ 178| | // Fill the buffer with what remains. 179| 27.2M| memcpy(buf + bufsize, data, end - data); 180| 27.2M| bytes += end - data; 181| 27.2M| } 182| 40.8M| return *this; 183| 40.8M|} _ZN7CSHA5128FinalizeEPh: 186| 13.6M|{ 187| 13.6M| static const unsigned char pad[128] = {0x80}; 188| 13.6M| unsigned char sizedesc[16] = {0x00}; 189| 13.6M| WriteBE64(sizedesc + 8, bytes << 3); 190| 13.6M| Write(pad, 1 + ((239 - (bytes % 128)) % 128)); 191| 13.6M| Write(sizedesc, 16); 192| 13.6M| WriteBE64(hash, s[0]); 193| 13.6M| WriteBE64(hash + 8, s[1]); 194| 13.6M| WriteBE64(hash + 16, s[2]); 195| 13.6M| WriteBE64(hash + 24, s[3]); 196| 13.6M| WriteBE64(hash + 32, s[4]); 197| 13.6M| WriteBE64(hash + 40, s[5]); 198| 13.6M| WriteBE64(hash + 48, s[6]); 199| 13.6M| WriteBE64(hash + 56, s[7]); 200| 13.6M|} _ZN7CSHA5125ResetEv: 203| 13.5M|{ 204| 13.5M| bytes = 0; 205| 13.5M| sha512::Initialize(s); 206| 13.5M| return *this; 207| 13.5M|} sha512.cpp:_ZN12_GLOBAL__N_16sha51210InitializeEPm: 35| 13.6M|{ 36| 13.6M| s[0] = 0x6a09e667f3bcc908ull; 37| 13.6M| s[1] = 0xbb67ae8584caa73bull; 38| 13.6M| s[2] = 0x3c6ef372fe94f82bull; 39| 13.6M| s[3] = 0xa54ff53a5f1d36f1ull; 40| 13.6M| s[4] = 0x510e527fade682d1ull; 41| 13.6M| s[5] = 0x9b05688c2b3e6c1full; 42| 13.6M| s[6] = 0x1f83d9abfb41bd6bull; 43| 13.6M| s[7] = 0x5be0cd19137e2179ull; 44| 13.6M|} sha512.cpp:_ZN12_GLOBAL__N_16sha5129TransformEPmPKh: 48| 13.6M|{ 49| 13.6M| uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7]; 50| 13.6M| uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15; 51| | 52| 13.6M| Round(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22ull, w0 = ReadBE64(chunk + 0)); 53| 13.6M| Round(h, a, b, c, d, e, f, g, 0x7137449123ef65cdull, w1 = ReadBE64(chunk + 8)); 54| 13.6M| Round(g, h, a, b, c, d, e, f, 0xb5c0fbcfec4d3b2full, w2 = ReadBE64(chunk + 16)); 55| 13.6M| Round(f, g, h, a, b, c, d, e, 0xe9b5dba58189dbbcull, w3 = ReadBE64(chunk + 24)); 56| 13.6M| Round(e, f, g, h, a, b, c, d, 0x3956c25bf348b538ull, w4 = ReadBE64(chunk + 32)); 57| 13.6M| Round(d, e, f, g, h, a, b, c, 0x59f111f1b605d019ull, w5 = ReadBE64(chunk + 40)); 58| 13.6M| Round(c, d, e, f, g, h, a, b, 0x923f82a4af194f9bull, w6 = ReadBE64(chunk + 48)); 59| 13.6M| Round(b, c, d, e, f, g, h, a, 0xab1c5ed5da6d8118ull, w7 = ReadBE64(chunk + 56)); 60| 13.6M| Round(a, b, c, d, e, f, g, h, 0xd807aa98a3030242ull, w8 = ReadBE64(chunk + 64)); 61| 13.6M| Round(h, a, b, c, d, e, f, g, 0x12835b0145706fbeull, w9 = ReadBE64(chunk + 72)); 62| 13.6M| Round(g, h, a, b, c, d, e, f, 0x243185be4ee4b28cull, w10 = ReadBE64(chunk + 80)); 63| 13.6M| Round(f, g, h, a, b, c, d, e, 0x550c7dc3d5ffb4e2ull, w11 = ReadBE64(chunk + 88)); 64| 13.6M| Round(e, f, g, h, a, b, c, d, 0x72be5d74f27b896full, w12 = ReadBE64(chunk + 96)); 65| 13.6M| Round(d, e, f, g, h, a, b, c, 0x80deb1fe3b1696b1ull, w13 = ReadBE64(chunk + 104)); 66| 13.6M| Round(c, d, e, f, g, h, a, b, 0x9bdc06a725c71235ull, w14 = ReadBE64(chunk + 112)); 67| 13.6M| Round(b, c, d, e, f, g, h, a, 0xc19bf174cf692694ull, w15 = ReadBE64(chunk + 120)); 68| | 69| 13.6M| Round(a, b, c, d, e, f, g, h, 0xe49b69c19ef14ad2ull, w0 += sigma1(w14) + w9 + sigma0(w1)); 70| 13.6M| Round(h, a, b, c, d, e, f, g, 0xefbe4786384f25e3ull, w1 += sigma1(w15) + w10 + sigma0(w2)); 71| 13.6M| Round(g, h, a, b, c, d, e, f, 0x0fc19dc68b8cd5b5ull, w2 += sigma1(w0) + w11 + sigma0(w3)); 72| 13.6M| Round(f, g, h, a, b, c, d, e, 0x240ca1cc77ac9c65ull, w3 += sigma1(w1) + w12 + sigma0(w4)); 73| 13.6M| Round(e, f, g, h, a, b, c, d, 0x2de92c6f592b0275ull, w4 += sigma1(w2) + w13 + sigma0(w5)); 74| 13.6M| Round(d, e, f, g, h, a, b, c, 0x4a7484aa6ea6e483ull, w5 += sigma1(w3) + w14 + sigma0(w6)); 75| 13.6M| Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcbd41fbd4ull, w6 += sigma1(w4) + w15 + sigma0(w7)); 76| 13.6M| Round(b, c, d, e, f, g, h, a, 0x76f988da831153b5ull, w7 += sigma1(w5) + w0 + sigma0(w8)); 77| 13.6M| Round(a, b, c, d, e, f, g, h, 0x983e5152ee66dfabull, w8 += sigma1(w6) + w1 + sigma0(w9)); 78| 13.6M| Round(h, a, b, c, d, e, f, g, 0xa831c66d2db43210ull, w9 += sigma1(w7) + w2 + sigma0(w10)); 79| 13.6M| Round(g, h, a, b, c, d, e, f, 0xb00327c898fb213full, w10 += sigma1(w8) + w3 + sigma0(w11)); 80| 13.6M| Round(f, g, h, a, b, c, d, e, 0xbf597fc7beef0ee4ull, w11 += sigma1(w9) + w4 + sigma0(w12)); 81| 13.6M| Round(e, f, g, h, a, b, c, d, 0xc6e00bf33da88fc2ull, w12 += sigma1(w10) + w5 + sigma0(w13)); 82| 13.6M| Round(d, e, f, g, h, a, b, c, 0xd5a79147930aa725ull, w13 += sigma1(w11) + w6 + sigma0(w14)); 83| 13.6M| Round(c, d, e, f, g, h, a, b, 0x06ca6351e003826full, w14 += sigma1(w12) + w7 + sigma0(w15)); 84| 13.6M| Round(b, c, d, e, f, g, h, a, 0x142929670a0e6e70ull, w15 += sigma1(w13) + w8 + sigma0(w0)); 85| | 86| 13.6M| Round(a, b, c, d, e, f, g, h, 0x27b70a8546d22ffcull, w0 += sigma1(w14) + w9 + sigma0(w1)); 87| 13.6M| Round(h, a, b, c, d, e, f, g, 0x2e1b21385c26c926ull, w1 += sigma1(w15) + w10 + sigma0(w2)); 88| 13.6M| Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc5ac42aedull, w2 += sigma1(w0) + w11 + sigma0(w3)); 89| 13.6M| Round(f, g, h, a, b, c, d, e, 0x53380d139d95b3dfull, w3 += sigma1(w1) + w12 + sigma0(w4)); 90| 13.6M| Round(e, f, g, h, a, b, c, d, 0x650a73548baf63deull, w4 += sigma1(w2) + w13 + sigma0(w5)); 91| 13.6M| Round(d, e, f, g, h, a, b, c, 0x766a0abb3c77b2a8ull, w5 += sigma1(w3) + w14 + sigma0(w6)); 92| 13.6M| Round(c, d, e, f, g, h, a, b, 0x81c2c92e47edaee6ull, w6 += sigma1(w4) + w15 + sigma0(w7)); 93| 13.6M| Round(b, c, d, e, f, g, h, a, 0x92722c851482353bull, w7 += sigma1(w5) + w0 + sigma0(w8)); 94| 13.6M| Round(a, b, c, d, e, f, g, h, 0xa2bfe8a14cf10364ull, w8 += sigma1(w6) + w1 + sigma0(w9)); 95| 13.6M| Round(h, a, b, c, d, e, f, g, 0xa81a664bbc423001ull, w9 += sigma1(w7) + w2 + sigma0(w10)); 96| 13.6M| Round(g, h, a, b, c, d, e, f, 0xc24b8b70d0f89791ull, w10 += sigma1(w8) + w3 + sigma0(w11)); 97| 13.6M| Round(f, g, h, a, b, c, d, e, 0xc76c51a30654be30ull, w11 += sigma1(w9) + w4 + sigma0(w12)); 98| 13.6M| Round(e, f, g, h, a, b, c, d, 0xd192e819d6ef5218ull, w12 += sigma1(w10) + w5 + sigma0(w13)); 99| 13.6M| Round(d, e, f, g, h, a, b, c, 0xd69906245565a910ull, w13 += sigma1(w11) + w6 + sigma0(w14)); 100| 13.6M| Round(c, d, e, f, g, h, a, b, 0xf40e35855771202aull, w14 += sigma1(w12) + w7 + sigma0(w15)); 101| 13.6M| Round(b, c, d, e, f, g, h, a, 0x106aa07032bbd1b8ull, w15 += sigma1(w13) + w8 + sigma0(w0)); 102| | 103| 13.6M| Round(a, b, c, d, e, f, g, h, 0x19a4c116b8d2d0c8ull, w0 += sigma1(w14) + w9 + sigma0(w1)); 104| 13.6M| Round(h, a, b, c, d, e, f, g, 0x1e376c085141ab53ull, w1 += sigma1(w15) + w10 + sigma0(w2)); 105| 13.6M| Round(g, h, a, b, c, d, e, f, 0x2748774cdf8eeb99ull, w2 += sigma1(w0) + w11 + sigma0(w3)); 106| 13.6M| Round(f, g, h, a, b, c, d, e, 0x34b0bcb5e19b48a8ull, w3 += sigma1(w1) + w12 + sigma0(w4)); 107| 13.6M| Round(e, f, g, h, a, b, c, d, 0x391c0cb3c5c95a63ull, w4 += sigma1(w2) + w13 + sigma0(w5)); 108| 13.6M| Round(d, e, f, g, h, a, b, c, 0x4ed8aa4ae3418acbull, w5 += sigma1(w3) + w14 + sigma0(w6)); 109| 13.6M| Round(c, d, e, f, g, h, a, b, 0x5b9cca4f7763e373ull, w6 += sigma1(w4) + w15 + sigma0(w7)); 110| 13.6M| Round(b, c, d, e, f, g, h, a, 0x682e6ff3d6b2b8a3ull, w7 += sigma1(w5) + w0 + sigma0(w8)); 111| 13.6M| Round(a, b, c, d, e, f, g, h, 0x748f82ee5defb2fcull, w8 += sigma1(w6) + w1 + sigma0(w9)); 112| 13.6M| Round(h, a, b, c, d, e, f, g, 0x78a5636f43172f60ull, w9 += sigma1(w7) + w2 + sigma0(w10)); 113| 13.6M| Round(g, h, a, b, c, d, e, f, 0x84c87814a1f0ab72ull, w10 += sigma1(w8) + w3 + sigma0(w11)); 114| 13.6M| Round(f, g, h, a, b, c, d, e, 0x8cc702081a6439ecull, w11 += sigma1(w9) + w4 + sigma0(w12)); 115| 13.6M| Round(e, f, g, h, a, b, c, d, 0x90befffa23631e28ull, w12 += sigma1(w10) + w5 + sigma0(w13)); 116| 13.6M| Round(d, e, f, g, h, a, b, c, 0xa4506cebde82bde9ull, w13 += sigma1(w11) + w6 + sigma0(w14)); 117| 13.6M| Round(c, d, e, f, g, h, a, b, 0xbef9a3f7b2c67915ull, w14 += sigma1(w12) + w7 + sigma0(w15)); 118| 13.6M| Round(b, c, d, e, f, g, h, a, 0xc67178f2e372532bull, w15 += sigma1(w13) + w8 + sigma0(w0)); 119| | 120| 13.6M| Round(a, b, c, d, e, f, g, h, 0xca273eceea26619cull, w0 += sigma1(w14) + w9 + sigma0(w1)); 121| 13.6M| Round(h, a, b, c, d, e, f, g, 0xd186b8c721c0c207ull, w1 += sigma1(w15) + w10 + sigma0(w2)); 122| 13.6M| Round(g, h, a, b, c, d, e, f, 0xeada7dd6cde0eb1eull, w2 += sigma1(w0) + w11 + sigma0(w3)); 123| 13.6M| Round(f, g, h, a, b, c, d, e, 0xf57d4f7fee6ed178ull, w3 += sigma1(w1) + w12 + sigma0(w4)); 124| 13.6M| Round(e, f, g, h, a, b, c, d, 0x06f067aa72176fbaull, w4 += sigma1(w2) + w13 + sigma0(w5)); 125| 13.6M| Round(d, e, f, g, h, a, b, c, 0x0a637dc5a2c898a6ull, w5 += sigma1(w3) + w14 + sigma0(w6)); 126| 13.6M| Round(c, d, e, f, g, h, a, b, 0x113f9804bef90daeull, w6 += sigma1(w4) + w15 + sigma0(w7)); 127| 13.6M| Round(b, c, d, e, f, g, h, a, 0x1b710b35131c471bull, w7 += sigma1(w5) + w0 + sigma0(w8)); 128| 13.6M| Round(a, b, c, d, e, f, g, h, 0x28db77f523047d84ull, w8 += sigma1(w6) + w1 + sigma0(w9)); 129| 13.6M| Round(h, a, b, c, d, e, f, g, 0x32caab7b40c72493ull, w9 += sigma1(w7) + w2 + sigma0(w10)); 130| 13.6M| Round(g, h, a, b, c, d, e, f, 0x3c9ebe0a15c9bebcull, w10 += sigma1(w8) + w3 + sigma0(w11)); 131| 13.6M| Round(f, g, h, a, b, c, d, e, 0x431d67c49c100d4cull, w11 += sigma1(w9) + w4 + sigma0(w12)); 132| 13.6M| Round(e, f, g, h, a, b, c, d, 0x4cc5d4becb3e42b6ull, w12 += sigma1(w10) + w5 + sigma0(w13)); 133| 13.6M| Round(d, e, f, g, h, a, b, c, 0x597f299cfc657e2aull, w13 += sigma1(w11) + w6 + sigma0(w14)); 134| 13.6M| Round(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faecull, w14 + sigma1(w12) + w7 + sigma0(w15)); 135| 13.6M| Round(b, c, d, e, f, g, h, a, 0x6c44198c4a475817ull, w15 + sigma1(w13) + w8 + sigma0(w0)); 136| | 137| 13.6M| s[0] += a; 138| 13.6M| s[1] += b; 139| 13.6M| s[2] += c; 140| 13.6M| s[3] += d; 141| 13.6M| s[4] += e; 142| 13.6M| s[5] += f; 143| 13.6M| s[6] += g; 144| 13.6M| s[7] += h; 145| 13.6M|} sha512.cpp:_ZN12_GLOBAL__N_16sha5125RoundEmmmRmmmmS1_mm: 26| 1.08G|{ 27| 1.08G| uint64_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w; 28| 1.08G| uint64_t t2 = Sigma0(a) + Maj(a, b, c); 29| 1.08G| d += t1; 30| 1.08G| h = t1 + t2; 31| 1.08G|} sha512.cpp:_ZN12_GLOBAL__N_16sha5126Sigma1Em: 20| 1.08G|uint64_t inline Sigma1(uint64_t x) { return (x >> 14 | x << 50) ^ (x >> 18 | x << 46) ^ (x >> 41 | x << 23); } sha512.cpp:_ZN12_GLOBAL__N_16sha5122ChEmmm: 17| 1.08G|uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x & (y ^ z)); } sha512.cpp:_ZN12_GLOBAL__N_16sha5126Sigma0Em: 19| 1.08G|uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >> 34 | x << 30) ^ (x >> 39 | x << 25); } sha512.cpp:_ZN12_GLOBAL__N_16sha5123MajEmmm: 18| 1.08G|uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & y) | (z & (x | y)); } sha512.cpp:_ZN12_GLOBAL__N_16sha5126sigma1Em: 22| 870M|uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >> 61 | x << 3) ^ (x >> 6); } sha512.cpp:_ZN12_GLOBAL__N_16sha5126sigma0Em: 21| 870M|uint64_t inline sigma0(uint64_t x) { return (x >> 1 | x << 63) ^ (x >> 8 | x << 56) ^ (x >> 7); } _ZN10CDBWrapperD2Ev: 279| 4|{ 280| 4| delete DBContext().pdb; 281| 4| DBContext().pdb = nullptr; 282| 4| delete DBContext().options.filter_policy; 283| 4| DBContext().options.filter_policy = nullptr; 284| 4| delete DBContext().options.info_log; 285| 4| DBContext().options.info_log = nullptr; 286| 4| delete DBContext().options.block_cache; 287| 4| DBContext().options.block_cache = nullptr; 288| 4| delete DBContext().penv; 289| 4| DBContext().options.env = nullptr; 290| 4|} _ZNK10CDBWrapper9DBContextEv: 212| 40| auto& DBContext() const LIFETIMEBOUND { return *Assert(m_db_context); } ------------------ | | 85| 40|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ _ZN8CHash2568FinalizeE4SpanIhE: 30| 7.36k| void Finalize(Span output) { 31| 7.36k| assert(output.size() == OUTPUT_SIZE); 32| 7.36k| unsigned char buf[CSHA256::OUTPUT_SIZE]; 33| 7.36k| sha.Finalize(buf); 34| 7.36k| sha.Reset().Write(buf, CSHA256::OUTPUT_SIZE).Finalize(output.data()); 35| 7.36k| } _ZN8CHash2565WriteE4SpanIKhE: 37| 7.36k| CHash256& Write(Span input) { 38| 7.36k| sha.Write(input.data(), input.size()); 39| 7.36k| return *this; 40| 7.36k| } _Z4HashI4SpanIKhEE7uint256RKT_: 76| 7.36k|{ 77| 7.36k| uint256 result; 78| 7.36k| CHash256().Write(MakeUCharSpan(in1)).Finalize(result); 79| 7.36k| return result; 80| 7.36k|} _ZN10interfaces5ChainD2Ev: 131| 2| virtual ~Chain() = default; _ZN6kernel13NotificationsD2Ev: 38| 2| virtual ~Notifications() = 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|} _ZN4CKeyC2Ev: 74| 7.36k| CKey() noexcept = default; _ZN7leveldb6DBImplD2Ev: 153| 4|DBImpl::~DBImpl() { 154| | // Wait for background work to finish. 155| 4| mutex_.Lock(); 156| 4| shutting_down_.store(true, std::memory_order_release); 157| 4| while (background_compaction_scheduled_) { ------------------ | Branch (157:10): [True: 0, False: 4] ------------------ 158| 0| background_work_finished_signal_.Wait(); 159| 0| } 160| 4| mutex_.Unlock(); 161| | 162| 4| if (db_lock_ != nullptr) { ------------------ | Branch (162:7): [True: 4, False: 0] ------------------ 163| 4| env_->UnlockFile(db_lock_); 164| 4| } 165| | 166| 4| delete versions_; 167| 4| if (mem_ != nullptr) mem_->Unref(); ------------------ | Branch (167:7): [True: 4, False: 0] ------------------ 168| 4| if (imm_ != nullptr) imm_->Unref(); ------------------ | Branch (168:7): [True: 0, False: 4] ------------------ 169| 4| delete tmp_batch_; 170| 4| delete log_; 171| 4| delete logfile_; 172| 4| delete table_cache_; 173| | 174| 4| if (owns_info_log_) { ------------------ | Branch (174:7): [True: 0, False: 4] ------------------ 175| 0| delete options_.info_log; 176| 0| } 177| 4| if (owns_cache_) { ------------------ | Branch (177:7): [True: 0, False: 4] ------------------ 178| 0| delete options_.block_cache; 179| 0| } 180| 4|} _ZN7leveldb2DBD2Ev: 1477| 4|DB::~DB() = default; _ZN7leveldb8SnapshotD2Ev: 1522| 4|Snapshot::~Snapshot() = default; _ZN7leveldb3log6WriterD2Ev: 32| 8|Writer::~Writer() = default; _ZN7leveldb8MemTableD2Ev: 24| 4|MemTable::~MemTable() { assert(refs_ == 0); } _ZN7leveldb8MemTable5UnrefEv: 33| 4| void Unref() { 34| 4| --refs_; 35| 4| assert(refs_ >= 0); 36| 4| if (refs_ <= 0) { ------------------ | Branch (36:9): [True: 4, False: 0] ------------------ 37| 4| delete this; 38| 4| } 39| 4| } _ZN7leveldb10TableCacheD2Ev: 39| 4|TableCache::~TableCache() { delete cache_; } _ZN7leveldb7VersionD2Ev: 68| 8|Version::~Version() { 69| 8| assert(refs_ == 0); 70| | 71| | // Remove from linked list 72| 8| prev_->next_ = next_; 73| 8| next_->prev_ = prev_; 74| | 75| | // Drop references to files 76| 64| for (int level = 0; level < config::kNumLevels; level++) { ------------------ | Branch (76:23): [True: 56, False: 8] ------------------ 77| 56| for (size_t i = 0; i < files_[level].size(); i++) { ------------------ | Branch (77:24): [True: 0, False: 56] ------------------ 78| 0| FileMetaData* f = files_[level][i]; 79| 0| assert(f->refs > 0); 80| 0| f->refs--; 81| 0| if (f->refs <= 0) { ------------------ | Branch (81:11): [True: 0, False: 0] ------------------ 82| 0| delete f; 83| 0| } 84| 0| } 85| 56| } 86| 8|} _ZN7leveldb7Version5UnrefEv: 456| 4|void Version::Unref() { 457| 4| assert(this != &vset_->dummy_versions_); 458| 4| assert(refs_ >= 1); 459| 4| --refs_; 460| 4| if (refs_ == 0) { ------------------ | Branch (460:7): [True: 4, False: 0] ------------------ 461| 4| delete this; 462| 4| } 463| 4|} _ZN7leveldb10VersionSetD2Ev: 754| 4|VersionSet::~VersionSet() { 755| 4| current_->Unref(); 756| 4| assert(dummy_versions_.next_ == &dummy_versions_); // List must be empty 757| 4| delete descriptor_log_; 758| 4| delete descriptor_file_; 759| 4|} _ZN7leveldb10WriteBatchD2Ev: 31| 4|WriteBatch::~WriteBatch() = default; memenv.cc:_ZN7leveldb12_GLOBAL__N_111InMemoryEnvD2Ev: 229| 4| ~InMemoryEnv() override { 230| 12| for (const auto& kvp : file_map_) { ------------------ | Branch (230:26): [True: 12, False: 4] ------------------ 231| 12| kvp.second->Unref(); 232| 12| } 233| 4| } memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileState5UnrefEv: 41| 20| void Unref() { 42| 20| bool do_delete = false; 43| | 44| 20| { 45| 20| MutexLock lock(&refs_mutex_); 46| 20| --refs_; 47| 20| assert(refs_ >= 0); 48| 20| if (refs_ <= 0) { ------------------ | Branch (48:11): [True: 12, False: 8] ------------------ 49| 12| do_delete = true; 50| 12| } 51| 20| } 52| | 53| 20| if (do_delete) { ------------------ | Branch (53:9): [True: 12, False: 8] ------------------ 54| 12| delete this; 55| 12| } 56| 20| } memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileStateD2Ev: 143| 12| ~FileState() { Truncate(); } memenv.cc:_ZN7leveldb12_GLOBAL__N_19FileState8TruncateEv: 63| 12| void Truncate() { 64| 12| MutexLock lock(&blocks_mutex_); 65| 12| for (char*& block : blocks_) { ------------------ | Branch (65:23): [True: 10, False: 12] ------------------ 66| 10| delete[] block; 67| 10| } 68| 12| blocks_.clear(); 69| 12| size_ = 0; 70| 12| } memenv.cc:_ZN7leveldb12_GLOBAL__N_116WritableFileImplD2Ev: 207| 8| ~WritableFileImpl() override { file_->Unref(); } memenv.cc:_ZN7leveldb12_GLOBAL__N_111InMemoryEnv10UnlockFileEPNS_8FileLockE: 367| 4| Status UnlockFile(FileLock* lock) override { 368| 4| delete lock; 369| 4| return Status::OK(); 370| 4| } _ZN7leveldb6StatusD2Ev: 28| 8| ~Status() { delete[] state_; } _ZN7leveldb6StatusC2Ev: 27| 4| Status() noexcept : state_(nullptr) {} _ZN7leveldb6Status2OKEv: 37| 4| static Status OK() { return Status(); } _ZN7leveldb4port7CondVarD2Ev: 68| 4| ~CondVar() = default; _ZN7leveldb4port5Mutex4LockEv: 55| 36| void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.lock(); } _ZN7leveldb4port5Mutex6UnlockEv: 56| 36| void Unlock() UNLOCK_FUNCTION() { mu_.unlock(); } _ZN7leveldb5ArenaD2Ev: 14| 4|Arena::~Arena() { 15| 8| for (size_t i = 0; i < blocks_.size(); i++) { ------------------ | Branch (15:22): [True: 4, False: 4] ------------------ 16| 4| delete[] blocks_[i]; 17| 4| } 18| 4|} _ZN7leveldb5CacheD2Ev: 17| 8|Cache::~Cache() {} cache.cc:_ZN7leveldb12_GLOBAL__N_18LRUCacheD2Ev: 205| 128|LRUCache::~LRUCache() { 206| 128| assert(in_use_.next == &in_use_); // Error if caller has an unreleased handle 207| 128| for (LRUHandle* e = lru_.next; e != &lru_;) { ------------------ | Branch (207:34): [True: 0, False: 128] ------------------ 208| 0| LRUHandle* next = e->next; 209| 0| assert(e->in_cache); 210| 0| e->in_cache = false; 211| 0| assert(e->refs == 1); // Invariant of lru_ list. 212| 0| Unref(e); 213| 0| e = next; 214| 0| } 215| 128|} cache.cc:_ZN7leveldb12_GLOBAL__N_111HandleTableD2Ev: 72| 128| ~HandleTable() { delete[] list_; } cache.cc:_ZN7leveldb12_GLOBAL__N_115ShardedLRUCacheD2Ev: 357| 8| ~ShardedLRUCache() override {} _ZN7leveldb10ComparatorD2Ev: 18| 16|Comparator::~Comparator() = default; _ZN7leveldb3EnvD2Ev: 9| 4|Env::~Env() = default; _ZN7leveldb12WritableFileD2Ev: 19| 8|WritableFile::~WritableFile() = default; _ZN7leveldb6LoggerD2Ev: 21| 4|Logger::~Logger() = default; _ZN7leveldb8FileLockD2Ev: 23| 4|FileLock::~FileLock() = default; _ZN7leveldb12FilterPolicyD2Ev: 9| 8|FilterPolicy::~FilterPolicy() {} _ZN7leveldb9MutexLockC2EPNS_4port5MutexE: 25| 32| explicit MutexLock(port::Mutex* mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) { 26| 32| this->mu_->Lock(); 27| 32| } _ZN7leveldb9MutexLockD2Ev: 28| 32| ~MutexLock() UNLOCK_FUNCTION() { this->mu_->Unlock(); } _Z11LogInstancev: 25| 4|{ 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| 4| static BCLog::Logger* g_logger{new BCLog::Logger()}; 42| 4| return *g_logger; 43| 4|} _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|} _ZNK5BCLog6Logger7EnabledEv: 150| 2| { 151| 2| StdLockGuard scoped_lock(m_cs); 152| 2| return m_buffering || m_print_to_console || m_print_to_file || !m_print_callbacks.empty(); ------------------ | Branch (152:20): [True: 0, False: 2] | Branch (152:35): [True: 0, False: 2] | Branch (152:57): [True: 0, False: 2] | Branch (152:76): [True: 0, False: 2] ------------------ 153| 2| } _Z22LogPrintFormatInternalIJNSt3__117basic_string_viewIcNS0_11char_traitsIcEEEEEEvS4_S4_iN5BCLog8LogFlagsENS5_5LevelEN4util21ConstevalFormatStringIXsZT_EEEDpRKT_: 243| 2|{ 244| 2| if (LogInstance().Enabled()) { ------------------ | Branch (244:9): [True: 0, False: 2] ------------------ 245| 0| std::string log_msg; 246| 0| try { 247| 0| log_msg = tfm::format(fmt, args...); 248| 0| } catch (tinyformat::format_error& fmterr) { 249| 0| log_msg = "Error \"" + std::string{fmterr.what()} + "\" while formatting log message: " + fmt.fmt; 250| 0| } 251| 0| LogInstance().LogPrintStr(log_msg, logging_function, source_file, source_line, flag, level); 252| 0| } 253| 2|} _ZN8CConnman9InterruptEv: 3416| 2|{ 3417| 2| { 3418| 2| LOCK(mutexMsgProc); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 3419| 2| flagInterruptMsgProc = true; 3420| 2| } 3421| 2| condMsgProc.notify_all(); 3422| | 3423| 2| interruptNet(); 3424| 2| g_socks5_interrupt(); 3425| | 3426| 2| if (semOutbound) { ------------------ | Branch (3426:9): [True: 0, False: 2] ------------------ 3427| 0| for (int i=0; ipost(); 3429| 0| } 3430| 0| } 3431| | 3432| 2| if (semAddnode) { ------------------ | Branch (3432:9): [True: 0, False: 2] ------------------ 3433| 0| for (int i=0; ipost(); 3435| 0| } 3436| 0| } 3437| 2|} _ZN8CConnman11StopThreadsEv: 3440| 2|{ 3441| 2| if (threadI2PAcceptIncoming.joinable()) { ------------------ | Branch (3441:9): [True: 0, False: 2] ------------------ 3442| 0| threadI2PAcceptIncoming.join(); 3443| 0| } 3444| 2| if (threadMessageHandler.joinable()) ------------------ | Branch (3444:9): [True: 0, False: 2] ------------------ 3445| 0| threadMessageHandler.join(); 3446| 2| if (threadOpenConnections.joinable()) ------------------ | Branch (3446:9): [True: 0, False: 2] ------------------ 3447| 0| threadOpenConnections.join(); 3448| 2| if (threadOpenAddedConnections.joinable()) ------------------ | Branch (3448:9): [True: 0, False: 2] ------------------ 3449| 0| threadOpenAddedConnections.join(); 3450| 2| if (threadDNSAddressSeed.joinable()) ------------------ | Branch (3450:9): [True: 0, False: 2] ------------------ 3451| 0| threadDNSAddressSeed.join(); 3452| 2| if (threadSocketHandler.joinable()) ------------------ | Branch (3452:9): [True: 0, False: 2] ------------------ 3453| 0| threadSocketHandler.join(); 3454| 2|} _ZN8CConnman9StopNodesEv: 3457| 2|{ 3458| 2| if (fAddressesInitialized) { ------------------ | Branch (3458:9): [True: 0, False: 2] ------------------ 3459| 0| DumpAddresses(); 3460| 0| fAddressesInitialized = false; 3461| | 3462| 0| if (m_use_addrman_outgoing) { ------------------ | Branch (3462:13): [True: 0, False: 0] ------------------ 3463| | // Anchor connections are only dumped during clean shutdown. 3464| 0| std::vector anchors_to_dump = GetCurrentBlockRelayOnlyConns(); 3465| 0| if (anchors_to_dump.size() > MAX_BLOCK_RELAY_ONLY_ANCHORS) { ------------------ | Branch (3465:17): [True: 0, False: 0] ------------------ 3466| 0| anchors_to_dump.resize(MAX_BLOCK_RELAY_ONLY_ANCHORS); 3467| 0| } 3468| 0| DumpAnchors(gArgs.GetDataDirNet() / ANCHORS_DATABASE_FILENAME, anchors_to_dump); 3469| 0| } 3470| 0| } 3471| | 3472| | // Delete peer connections. 3473| 2| std::vector nodes; 3474| 2| WITH_LOCK(m_nodes_mutex, nodes.swap(m_nodes)); ------------------ | | 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ 3475| 2| for (CNode* pnode : nodes) { ------------------ | Branch (3475:23): [True: 0, False: 2] ------------------ 3476| 0| LogDebug(BCLog::NET, "Stopping node, %s", pnode->DisconnectMsg(fLogIPs)); ------------------ | | 280| 0|#define LogDebug(category, ...) LogPrintLevel(category, BCLog::Level::Debug, __VA_ARGS__) | | ------------------ | | | | 273| 0| do { \ | | | | 274| 0| if (LogAcceptCategory((category), (level))) { \ | | | | ------------------ | | | | | Branch (274:13): [True: 0, False: 0] | | | | ------------------ | | | | 275| 0| LogPrintLevel_(category, level, __VA_ARGS__); \ | | | | ------------------ | | | | | | 255| 0|#define LogPrintLevel_(category, level, ...) LogPrintFormatInternal(__func__, __FILE__, __LINE__, category, level, __VA_ARGS__) | | | | ------------------ | | | | 276| 0| } \ | | | | 277| 0| } while (0) | | | | ------------------ | | | | | Branch (277:14): [Folded - Ignored] | | | | ------------------ | | ------------------ ------------------ 3477| 0| pnode->CloseSocketDisconnect(); 3478| 0| DeleteNode(pnode); 3479| 0| } 3480| | 3481| 2| for (CNode* pnode : m_nodes_disconnected) { ------------------ | Branch (3481:23): [True: 0, False: 2] ------------------ 3482| 0| DeleteNode(pnode); 3483| 0| } 3484| 2| m_nodes_disconnected.clear(); 3485| 2| vhListenSocket.clear(); 3486| 2| semOutbound.reset(); 3487| 2| semAddnode.reset(); 3488| 2|} _ZN8CConnmanD2Ev: 3498| 2|{ 3499| 2| Interrupt(); 3500| 2| Stop(); 3501| 2|} _ZN8CConnman4StopEv: 1130| 2| { 1131| 2| StopThreads(); 1132| 2| StopNodes(); 1133| 2| }; _ZN11PeerManagerD2Ev: 86| 2| virtual ~PeerManager() = default; _ZN4node11NodeContextD2Ev: 26| 2|NodeContext::~NodeContext() = default; _ZN4node17TxDownloadManagerD2Ev: 20| 2|TxDownloadManager::~TxDownloadManager() = default; _ZNK9prevectorILj28EhjiE9is_directEv: 173| 2| bool is_direct() const { return _size <= N; } _ZN9prevectorILj28EhjiED2Ev: 474| 2| ~prevector() { 475| 2| if (!is_direct()) { ------------------ | Branch (475:13): [True: 0, False: 2] ------------------ 476| 0| free(_union.indirect_contents.indirect); 477| 0| _union.indirect_contents.indirect = nullptr; 478| 0| } 479| 2| } _ZN7CPubKey6GetLenEh: 61| 14.0k| { 62| 14.0k| if (chHeader == 2 || chHeader == 3) ------------------ | Branch (62:13): [True: 374, False: 13.7k] | Branch (62:30): [True: 662, False: 13.0k] ------------------ 63| 1.03k| return COMPRESSED_SIZE; 64| 13.0k| if (chHeader == 4 || chHeader == 6 || chHeader == 7) ------------------ | Branch (64:13): [True: 971, False: 12.0k] | Branch (64:30): [True: 323, False: 11.7k] | Branch (64:47): [True: 264, False: 11.5k] ------------------ 65| 1.55k| return SIZE; 66| 11.5k| return 0; 67| 13.0k| } _ZN7CPubKey10InvalidateEv: 71| 9.68k| { 72| 9.68k| vch[0] = 0xFF; 73| 9.68k| } _ZN7CPubKeyC2Ev: 83| 7.76k| { 84| 7.76k| Invalidate(); 85| 7.76k| } _ZNK7CPubKey4sizeEv: 112| 14.0k| unsigned int size() const { return GetLen(vch[0]); } _ZNK7CPubKey7GetHashEv: 171| 7.36k| { 172| 7.36k| return Hash(Span{vch}.first(size())); 173| 7.36k| } _ZN7CPubKey11UnserializeI10DataStreamEEvRT_: 149| 7.76k| { 150| 7.76k| const unsigned int len(::ReadCompactSize(s)); 151| 7.76k| if (len <= SIZE) { ------------------ | Branch (151:13): [True: 6.76k, False: 1.00k] ------------------ 152| 6.76k| s >> Span{vch, len}; 153| 6.76k| if (len != size()) { ------------------ | Branch (153:17): [True: 1.27k, False: 5.48k] ------------------ 154| 1.27k| Invalidate(); 155| 1.27k| } 156| 6.76k| } else { 157| | // invalid pubkey, skip available data 158| 1.00k| s.ignore(len); 159| 1.00k| Invalidate(); 160| 1.00k| } 161| 7.76k| } _ZN10CSchedulerD2Ev: 17| 2|{ 18| 2| assert(nThreadsServicingQueue == 0); 19| 2| if (stopWhenEmpty) assert(taskQueue.empty()); ------------------ | Branch (19:9): [True: 0, False: 2] ------------------ 20| 2|} _ZN10CScheduler12serviceQueueEv: 24| 0|{ 25| 0| WAIT_LOCK(newTaskMutex, lock); ------------------ | | 262| 0|#define WAIT_LOCK(cs, name) UniqueLock name(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) ------------------ 26| 0| ++nThreadsServicingQueue; 27| | 28| | // newTaskMutex is locked throughout this loop EXCEPT 29| | // when the thread is waiting or when the user's function 30| | // is called. 31| 2| while (!shouldStop()) { ------------------ | Branch (31:12): [True: 0, False: 2] ------------------ 32| 0| try { 33| 0| while (!shouldStop() && taskQueue.empty()) { ------------------ | Branch (33:20): [True: 0, False: 0] | Branch (33:37): [True: 0, False: 0] ------------------ 34| | // Wait until there is something to do. 35| 0| newTaskScheduled.wait(lock); 36| 0| } 37| | 38| | // Wait until either there is a new task, or until 39| | // the time of the first item on the queue: 40| | 41| 0| while (!shouldStop() && !taskQueue.empty()) { ------------------ | Branch (41:20): [True: 0, False: 0] | Branch (41:37): [True: 0, False: 0] ------------------ 42| 0| std::chrono::steady_clock::time_point timeToWaitFor = taskQueue.begin()->first; 43| 0| if (newTaskScheduled.wait_until(lock, timeToWaitFor) == std::cv_status::timeout) { ------------------ | Branch (43:21): [True: 0, False: 0] ------------------ 44| 0| break; // Exit loop after timeout, it means we reached the time of the event 45| 0| } 46| 0| } 47| | 48| | // If there are multiple threads, the queue can empty while we're waiting (another 49| | // thread may service the task we were waiting on). 50| 0| if (shouldStop() || taskQueue.empty()) ------------------ | Branch (50:17): [True: 0, False: 0] | Branch (50:33): [True: 0, False: 0] ------------------ 51| 2| continue; 52| | 53| 18.4E| Function f = taskQueue.begin()->second; 54| 18.4E| taskQueue.erase(taskQueue.begin()); 55| | 56| 18.4E| { 57| | // Unlock before calling f, so it can reschedule itself or another task 58| | // without deadlocking: 59| 18.4E| REVERSE_LOCK(lock); ------------------ | | 243| 18.4E|#define REVERSE_LOCK(g) typename std::decay::type::reverse_lock UNIQUE_NAME(revlock)(g, #g, __FILE__, __LINE__) | | ------------------ | | | | 11| 18.4E|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 18.4E|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 18.4E|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 60| 18.4E| f(); 61| 18.4E| } 62| 18.4E| } catch (...) { 63| 0| --nThreadsServicingQueue; 64| 0| throw; 65| 0| } 66| 0| } 67| 2| --nThreadsServicingQueue; 68| 2| newTaskScheduled.notify_one(); 69| 2|} _ZNK10CScheduler24AreThreadsServicingQueueEv: 126| 2|{ 127| 2| LOCK(newTaskMutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 128| 2| return nThreadsServicingQueue; 129| 2|} _ZN16SerialTaskRunner12ProcessQueueEv: 146| 2|{ 147| 2| std::function callback; 148| 2| { 149| 2| LOCK(m_callbacks_mutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 150| 2| if (m_are_callbacks_running) return; ------------------ | Branch (150:13): [True: 0, False: 2] ------------------ 151| 2| if (m_callbacks_pending.empty()) return; ------------------ | Branch (151:13): [True: 2, False: 0] ------------------ 152| 0| m_are_callbacks_running = true; 153| | 154| 0| callback = std::move(m_callbacks_pending.front()); 155| 0| m_callbacks_pending.pop_front(); 156| 0| } 157| | 158| | // RAII the setting of fCallbacksRunning and calling MaybeScheduleProcessQueue 159| | // to ensure both happen safely even if callback() throws. 160| 0| struct RAIICallbacksRunning { 161| 0| SerialTaskRunner* instance; 162| 0| explicit RAIICallbacksRunning(SerialTaskRunner* _instance) : instance(_instance) {} 163| 0| ~RAIICallbacksRunning() 164| 0| { 165| 0| { 166| 0| LOCK(instance->m_callbacks_mutex); 167| 0| instance->m_are_callbacks_running = false; 168| 0| } 169| 0| instance->MaybeScheduleProcessQueue(); 170| 0| } 171| 0| } raiicallbacksrunning(this); 172| | 173| 0| callback(); 174| 0|} _ZN16SerialTaskRunner5flushEv: 186| 2|{ 187| 2| assert(!m_scheduler.AreThreadsServicingQueue()); 188| 2| bool should_continue = true; 189| 4| while (should_continue) { ------------------ | Branch (189:12): [True: 2, False: 2] ------------------ 190| 2| ProcessQueue(); 191| 2| LOCK(m_callbacks_mutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 192| 2| should_continue = !m_callbacks_pending.empty(); 193| 2| } 194| 2|} _ZN10CScheduler4stopEv: 80| 2| { 81| 2| WITH_LOCK(newTaskMutex, stopRequested = true); ------------------ | | 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ 82| 2| newTaskScheduled.notify_all(); 83| 2| if (m_service_thread.joinable()) m_service_thread.join(); ------------------ | Branch (83:13): [True: 2, False: 0] ------------------ 84| 2| } _ZNK10CScheduler10shouldStopEv: 111| 8| bool shouldStop() const EXCLUSIVE_LOCKS_REQUIRED(newTaskMutex) { return stopRequested || (stopWhenEmpty && taskQueue.empty()); } ------------------ | Branch (111:77): [True: 8, False: 0] | Branch (111:95): [True: 0, False: 0] | Branch (111:112): [True: 0, False: 0] ------------------ 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|} _Z14ser_readdata32I10DataStreamEjRT_: 102| 75|{ 103| 75| uint32_t obj; 104| 75| s.read(AsWritableBytes(Span{&obj, 1})); 105| 75| return le32toh_internal(obj); 106| 75|} _Z15ReadCompactSizeI10DataStreamEmRT_b: 340| 7.76k|{ 341| 7.76k| uint8_t chSize = ser_readdata8(is); 342| 7.76k| uint64_t nSizeRet = 0; 343| 7.76k| if (chSize < 253) ------------------ | Branch (343:9): [True: 7.41k, False: 355] ------------------ 344| 7.41k| { 345| 7.41k| nSizeRet = chSize; 346| 7.41k| } 347| 355| else if (chSize == 253) ------------------ | Branch (347:14): [True: 100, False: 255] ------------------ 348| 100| { 349| 100| nSizeRet = ser_readdata16(is); 350| 100| if (nSizeRet < 253) ------------------ | Branch (350:13): [True: 9, False: 91] ------------------ 351| 9| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 352| 100| } 353| 255| else if (chSize == 254) ------------------ | Branch (353:14): [True: 75, False: 180] ------------------ 354| 75| { 355| 75| nSizeRet = ser_readdata32(is); 356| 75| if (nSizeRet < 0x10000u) ------------------ | Branch (356:13): [True: 17, False: 58] ------------------ 357| 17| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 358| 75| } 359| 180| else 360| 180| { 361| 180| nSizeRet = ser_readdata64(is); 362| 180| if (nSizeRet < 0x100000000ULL) ------------------ | Branch (362:13): [True: 41, False: 139] ------------------ 363| 41| throw std::ios_base::failure("non-canonical ReadCompactSize()"); 364| 180| } 365| 7.70k| if (range_check && nSizeRet > MAX_SIZE) { ------------------ | Branch (365:9): [True: 7.67k, False: 26] | Branch (365:24): [True: 133, False: 7.54k] ------------------ 366| 133| throw std::ios_base::failure("ReadCompactSize(): size too large"); 367| 133| } 368| 7.56k| return nSizeRet; 369| 7.70k|} _Z13ser_readdata8I10DataStreamEhRT_: 84| 7.76k|{ 85| 7.76k| uint8_t obj; 86| 7.76k| s.read(AsWritableBytes(Span{&obj, 1})); 87| 7.76k| return obj; 88| 7.76k|} _Z14ser_readdata16I10DataStreamEtRT_: 90| 100|{ 91| 100| uint16_t obj; 92| 100| s.read(AsWritableBytes(Span{&obj, 1})); 93| 100| return le16toh_internal(obj); 94| 100|} _Z14ser_readdata64I10DataStreamEmRT_: 114| 157|{ 115| 157| uint64_t obj; 116| 157| s.read(AsWritableBytes(Span{&obj, 1})); 117| 157| return le64toh_internal(obj); 118| 157|} _Z11UnserializeI10DataStreamTk9BasicBytehEvRT_4SpanIT0_E: 283| 6.76k|template void Unserialize(Stream& s, Span span) { s.read(AsWritableBytes(span)); } _Z11UnserializeI10DataStreamR7CPubKeyQ14UnserializableIT0_T_EEvRS4_OS3_: 762| 7.76k|{ 763| 7.76k| a.Unserialize(is); 764| 7.76k|} _Z9UCharCastPKc: 284| 859|inline const unsigned char* UCharCast(const char* c) { return reinterpret_cast(c); } _Z9UCharCastPKh: 285| 7.36k|inline const unsigned char* UCharCast(const unsigned char* c) { return c; } _ZNK4SpanIKSt4byteE4sizeEv: 187| 7.76k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKSt4byteE4dataEv: 174| 15.5k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE4sizeEv: 187| 18.9k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIKhE5beginEv: 175| 4.21k| constexpr C* begin() const noexcept { return m_data; } _ZNK4SpanIKhE3endEv: 176| 4.21k| constexpr C* end() const noexcept { return m_data + m_size; } _ZNK4SpanIhE4sizeEv: 187| 7.36k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanIhE4dataEv: 174| 21.9k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE4dataEv: 174| 22.5k| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIKhE5firstEm: 206| 7.36k| { 207| 7.36k| ASSERT_IF_DEBUG(size() >= count); 208| 7.36k| return Span(m_data, count); 209| 7.36k| } _ZNK4SpanISt4byteE4sizeEv: 187| 35.6k| constexpr std::size_t size() const noexcept { return m_size; } _ZNK4SpanISt4byteE4dataEv: 174| 10.3k| constexpr C* data() const noexcept { return m_data; } _Z13UCharSpanCastIKhE4SpanINSt3__114remove_pointerIDTcl9UCharCastcldtfp_4dataEEEE4typeEES1_IT_E: 293| 7.36k|template constexpr auto UCharSpanCast(Span s) -> Span::type> { return {UCharCast(s.data()), s.size()}; } _Z13MakeUCharSpanIRK4SpanIKhEEDTcl13UCharSpanCasttlS0_clsr3stdE7forwardIT_Efp_EEEEOS5_: 296| 7.36k|template constexpr auto MakeUCharSpan(V&& v) -> decltype(UCharSpanCast(Span{std::forward(v)})) { return UCharSpanCast(Span{std::forward(v)}); } _ZNK4SpanIKhE10size_bytesEv: 188| 7.76k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _Z7AsBytesIKhE4SpanIKSt4byteES1_IT_E: 259| 7.76k|{ 260| 7.76k| return {reinterpret_cast(s.data()), s.size_bytes()}; 261| 7.76k|} _ZN4SpanIKhEC2INSt3__16vectorIhNS3_9allocatorIhEEEEEERKT_NS3_9enable_ifIXaaaantsr7is_SpanIS8_EE5valuesr3std14is_convertibleIPA_NS3_14remove_pointerIDTcldtclsr3stdE7declvalISA_EE4dataEEE4typeEPA_S0_EE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalISA_EE4sizeEEmEE5valueEDnE4typeE: 172| 11.9k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKSt4byteEC2IS1_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S1_EE5valueEiE4typeELi0EEEPS6_m: 119| 7.76k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZNK4SpanIjE4dataEv: 174| 75| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanIjE10size_bytesEv: 188| 75| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZNK4SpanIhE10size_bytesEv: 188| 14.5k| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZNK4SpanItE4dataEv: 174| 100| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanItE10size_bytesEv: 188| 100| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZNK4SpanImE4dataEv: 174| 157| constexpr C* data() const noexcept { return m_data; } _ZNK4SpanImE10size_bytesEv: 188| 157| constexpr std::size_t size_bytes() const noexcept { return sizeof(C) * m_size; } _ZN4SpanIKhEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 14.7k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanISt4byteEC2IS0_TnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_S0_EE5valueEiE4typeELi0EEEPS5_m: 119| 14.8k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIhE4SpanISt4byteES0_IT_E: 264| 14.5k|{ 265| 14.5k| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 14.5k|} _ZN4SpanIhEC2IhTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_hEE5valueEiE4typeELi0EEEPS4_m: 119| 14.5k| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesItE4SpanISt4byteES0_IT_E: 264| 100|{ 265| 100| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 100|} _ZN4SpanItEC2ItTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_tEE5valueEiE4typeELi0EEEPS4_m: 119| 100| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesIjE4SpanISt4byteES0_IT_E: 264| 75|{ 265| 75| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 75|} _ZN4SpanIjEC2IjTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_jEE5valueEiE4typeELi0EEEPS4_m: 119| 75| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _Z15AsWritableBytesImE4SpanISt4byteES0_IT_E: 264| 157|{ 265| 157| return {reinterpret_cast(s.data()), s.size_bytes()}; 266| 157|} _ZN4SpanImEC2ImTnNSt3__19enable_ifIXsr3std14is_convertibleIPA_T_PA_mEE5valueEiE4typeELi0EEEPS4_m: 119| 157| constexpr Span(T* begin, std::size_t size) noexcept : m_data(begin), m_size(size) {} _ZN4SpanIhEC2I7uint256EERT_NSt3__19enable_ifIXaaaantsr7is_SpanIS3_EE5valuesr3std14is_convertibleIPA_NS5_14remove_pointerIDTcldtclsr3stdE7declvalIS4_EE4dataEEE4typeEPA_hEE5valuesr3std14is_convertibleIDTcldtclsr3stdE7declvalIS4_EE4sizeEEmEE5valueEDnE4typeE: 165| 7.36k| : m_data(other.data()), m_size(other.size()){} _ZN4SpanIKhEC2ILi65EEERAT__S0_: 151| 7.36k| constexpr Span(C (&a)[N]) noexcept : m_data(a), m_size(N) {} _ZN10DataStreamC2E4SpanIKhE: 165| 7.76k| explicit DataStream(Span sp) : DataStream{AsBytes(sp)} {} _ZN10DataStreamC2E4SpanIKSt4byteE: 166| 7.76k| explicit DataStream(Span sp) : vch(sp.data(), sp.data() + sp.size()) {} _ZN10DataStream4readE4SpanISt4byteE: 219| 14.8k| { 220| 14.8k| if (dst.size() == 0) return; ------------------ | Branch (220:13): [True: 4.42k, False: 10.4k] ------------------ 221| | 222| | // Read from the beginning of the buffer 223| 10.4k| auto next_read_pos{CheckedAdd(m_read_pos, dst.size())}; 224| 10.4k| if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { ------------------ | Branch (224:13): [True: 0, False: 10.4k] | Branch (224:43): [True: 63, False: 10.3k] ------------------ 225| 63| throw std::ios_base::failure("DataStream::read(): end of data"); 226| 63| } 227| 10.3k| memcpy(dst.data(), &vch[m_read_pos], dst.size()); 228| 10.3k| if (next_read_pos.value() == vch.size()) { ------------------ | Branch (228:13): [True: 3.82k, False: 6.55k] ------------------ 229| 3.82k| m_read_pos = 0; 230| 3.82k| vch.clear(); 231| 3.82k| return; 232| 3.82k| } 233| 6.55k| m_read_pos = next_read_pos.value(); 234| 6.55k| } _ZN10DataStream6ignoreEm: 237| 776| { 238| | // Ignore from the beginning of the buffer 239| 776| auto next_read_pos{CheckedAdd(m_read_pos, num_ignore)}; 240| 776| if (!next_read_pos.has_value() || next_read_pos.value() > vch.size()) { ------------------ | Branch (240:13): [True: 0, False: 776] | Branch (240:43): [True: 140, False: 636] ------------------ 241| 140| throw std::ios_base::failure("DataStream::ignore(): end of data"); 242| 140| } 243| 636| if (next_read_pos.value() == vch.size()) { ------------------ | Branch (243:13): [True: 111, False: 525] ------------------ 244| 111| m_read_pos = 0; 245| 111| vch.clear(); 246| 111| return; 247| 111| } 248| 525| m_read_pos = next_read_pos.value(); 249| 525| } _ZN10DataStreamrsI4SpanIhEEERS_OT_: 266| 6.76k| { 267| 6.76k| ::Unserialize(*this, obj); 268| 6.76k| return (*this); 269| 6.76k| } _ZN10DataStreamrsIR7CPubKeyEERS_OT_: 266| 7.76k| { 267| 7.76k| ::Unserialize(*this, obj); 268| 7.76k| return (*this); 269| 7.76k| } _ZN12PoolResourceILm144ELm8EED2Ev: 201| 2| { 202| 2| for (std::byte* chunk : m_allocated_chunks) { ------------------ | Branch (202:31): [True: 2, False: 2] ------------------ 203| 2| std::destroy(chunk, chunk + m_chunk_size_bytes); 204| 2| ::operator delete ((void*)chunk, std::align_val_t{ELEM_ALIGN_BYTES}); 205| 2| } 206| 2| } _ZN16secure_allocatorIhE10deallocateEPhm: 37| 47.3k| { 38| 47.3k| if (p != nullptr) { ------------------ | Branch (38:13): [True: 47.3k, False: 0] ------------------ 39| 47.3k| memory_cleanse(p, sizeof(T) * n); 40| 47.3k| } 41| 47.3k| LockedPoolManager::Instance().free(p); 42| 47.3k| } _ZN16secure_allocatorIhE8allocateEm: 28| 47.3k| { 29| 47.3k| T* allocation = static_cast(LockedPoolManager::Instance().alloc(sizeof(T) * n)); 30| 47.3k| if (!allocation) { ------------------ | Branch (30:13): [True: 0, False: 47.3k] ------------------ 31| 0| throw std::bad_alloc(); 32| 0| } 33| 47.3k| return allocation; 34| 47.3k| } _ZN16secure_allocatorIcE8allocateEm: 28| 153| { 29| 153| T* allocation = static_cast(LockedPoolManager::Instance().alloc(sizeof(T) * n)); 30| 153| if (!allocation) { ------------------ | Branch (30:13): [True: 0, False: 153] ------------------ 31| 0| throw std::bad_alloc(); 32| 0| } 33| 153| return allocation; 34| 153| } _ZN16secure_allocatorIcE10deallocateEPcm: 37| 153| { 38| 153| if (p != nullptr) { ------------------ | Branch (38:13): [True: 153, False: 0] ------------------ 39| 153| memory_cleanse(p, sizeof(T) * n); 40| 153| } 41| 153| LockedPoolManager::Instance().free(p); 42| 153| } _ZneIhEbRK16secure_allocatorIhERKS0_IT_E: 51| 875| { 52| 875| return false; 53| 875| } _ZN25zero_after_free_allocatorISt4byteE10deallocateEPS0_m: 30| 7.74k| { 31| 7.74k| if (p != nullptr) ------------------ | Branch (31:13): [True: 7.74k, False: 0] ------------------ 32| 7.74k| memory_cleanse(p, sizeof(T) * n); 33| 7.74k| std::allocator{}.deallocate(p, n); 34| 7.74k| } _ZN25zero_after_free_allocatorISt4byteE8allocateEm: 25| 7.74k| { 26| 7.74k| return std::allocator{}.allocate(n); 27| 7.74k| } _Z14memory_cleansePvm: 15| 83.1k|{ 16| |#if defined(WIN32) 17| | /* SecureZeroMemory is guaranteed not to be optimized out. */ 18| | SecureZeroMemory(ptr, len); 19| |#else 20| 83.1k| 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| 83.1k| __asm__ __volatile__("" : : "r"(ptr) : "memory"); 34| 83.1k|#endif 35| 83.1k|} _ZN5Arena5allocEm: 52| 47.4k|{ 53| | // Round to next multiple of alignment 54| 47.4k| size = align_up(size, alignment); 55| | 56| | // Don't handle zero-sized chunks 57| 47.4k| if (size == 0) ------------------ | Branch (57:9): [True: 0, False: 47.4k] ------------------ 58| 0| return nullptr; 59| | 60| | // Pick a large enough free-chunk. Returns an iterator pointing to the first element that is not less than key. 61| | // This allocation strategy is best-fit. According to "Dynamic Storage Allocation: A Survey and Critical Review", 62| | // Wilson et. al. 1995, https://www.scs.stanford.edu/14wi-cs140/sched/readings/wilson.pdf, best-fit and first-fit 63| | // policies seem to work well in practice. 64| 47.4k| auto size_ptr_it = size_to_free_chunk.lower_bound(size); 65| 47.4k| if (size_ptr_it == size_to_free_chunk.end()) ------------------ | Branch (65:9): [True: 0, False: 47.4k] ------------------ 66| 0| return nullptr; 67| | 68| | // Create the used-chunk, taking its space from the end of the free-chunk 69| 47.4k| const size_t size_remaining = size_ptr_it->first - size; 70| 47.4k| char* const free_chunk = static_cast(size_ptr_it->second); 71| 47.4k| auto allocated = chunks_used.emplace(free_chunk + size_remaining, size).first; 72| 47.4k| chunks_free_end.erase(free_chunk + size_ptr_it->first); 73| 47.4k| if (size_ptr_it->first == size) { ------------------ | Branch (73:9): [True: 2.38k, False: 45.1k] ------------------ 74| | // whole chunk is used up 75| 2.38k| chunks_free.erase(size_ptr_it->second); 76| 45.1k| } else { 77| | // still some memory left in the chunk 78| 45.1k| auto it_remaining = size_to_free_chunk.emplace(size_remaining, size_ptr_it->second); 79| 45.1k| chunks_free[size_ptr_it->second] = it_remaining; 80| 45.1k| chunks_free_end.emplace(free_chunk + size_remaining, it_remaining); 81| 45.1k| } 82| 47.4k| size_to_free_chunk.erase(size_ptr_it); 83| | 84| 47.4k| return allocated->first; 85| 47.4k|} _ZN5Arena4freeEPv: 88| 47.4k|{ 89| | // Freeing the nullptr pointer is OK. 90| 47.4k| if (ptr == nullptr) { ------------------ | Branch (90:9): [True: 0, False: 47.4k] ------------------ 91| 0| return; 92| 0| } 93| | 94| | // Remove chunk from used map 95| 47.4k| auto i = chunks_used.find(ptr); 96| 47.4k| if (i == chunks_used.end()) { ------------------ | Branch (96:9): [True: 0, False: 47.4k] ------------------ 97| 0| throw std::runtime_error("Arena: invalid or double free"); 98| 0| } 99| 47.4k| auto freed = std::make_pair(static_cast(i->first), i->second); 100| 47.4k| chunks_used.erase(i); 101| | 102| | // coalesce freed with previous chunk 103| 47.4k| auto prev = chunks_free_end.find(freed.first); 104| 47.4k| if (prev != chunks_free_end.end()) { ------------------ | Branch (104:9): [True: 37.7k, False: 9.78k] ------------------ 105| 37.7k| freed.first -= prev->second->first; 106| 37.7k| freed.second += prev->second->first; 107| 37.7k| size_to_free_chunk.erase(prev->second); 108| 37.7k| chunks_free_end.erase(prev); 109| 37.7k| } 110| | 111| | // coalesce freed with chunk after freed 112| 47.4k| auto next = chunks_free.find(freed.first + freed.second); 113| 47.4k| if (next != chunks_free.end()) { ------------------ | Branch (113:9): [True: 7.40k, False: 40.0k] ------------------ 114| 7.40k| freed.second += next->second->first; 115| 7.40k| size_to_free_chunk.erase(next->second); 116| 7.40k| chunks_free.erase(next); 117| 7.40k| } 118| | 119| | // Add/set space with coalesced free chunk 120| 47.4k| auto it = size_to_free_chunk.emplace(freed.second, freed.first); 121| 47.4k| chunks_free[freed.first] = it; 122| 47.4k| chunks_free_end[freed.first + freed.second] = it; 123| 47.4k|} _ZN10LockedPool5allocEm: 286| 47.4k|{ 287| 47.4k| std::lock_guard lock(mutex); 288| | 289| | // Don't handle impossible sizes 290| 47.4k| if (size == 0 || size > ARENA_SIZE) ------------------ | Branch (290:9): [True: 0, False: 47.4k] | Branch (290:22): [True: 0, False: 47.4k] ------------------ 291| 0| return nullptr; 292| | 293| | // Try allocating from each current arena 294| 47.4k| for (auto &arena: arenas) { ------------------ | Branch (294:21): [True: 47.4k, False: 0] ------------------ 295| 47.4k| void *addr = arena.alloc(size); 296| 47.4k| if (addr) { ------------------ | Branch (296:13): [True: 47.4k, False: 0] ------------------ 297| 47.4k| return addr; 298| 47.4k| } 299| 47.4k| } 300| | // If that fails, create a new one 301| 0| if (new_arena(ARENA_SIZE, ARENA_ALIGN)) { ------------------ | Branch (301:9): [True: 0, False: 0] ------------------ 302| 0| return arenas.back().alloc(size); 303| 0| } 304| 0| return nullptr; 305| 0|} _ZN10LockedPool4freeEPv: 308| 47.4k|{ 309| 47.4k| std::lock_guard lock(mutex); 310| | // TODO we can do better than this linear search by keeping a map of arena 311| | // extents to arena, and looking up the address. 312| 47.4k| for (auto &arena: arenas) { ------------------ | Branch (312:21): [True: 47.4k, False: 0] ------------------ 313| 47.4k| if (arena.addressInArena(ptr)) { ------------------ | Branch (313:13): [True: 47.4k, False: 0] ------------------ 314| 47.4k| arena.free(ptr); 315| 47.4k| return; 316| 47.4k| } 317| 47.4k| } 318| 0| throw std::runtime_error("LockedPool: invalid address not pointing to any arena"); 319| 47.4k|} lockedpool.cpp:_ZL8align_upmm: 33| 47.4k|{ 34| 47.4k| return (x + align - 1) & ~(align - 1); 35| 47.4k|} _ZNK5Arena14addressInArenaEPv: 90| 47.4k| bool addressInArena(void *ptr) const { return ptr >= base && ptr < end; } ------------------ | Branch (90:51): [True: 47.4k, False: 0] | Branch (90:66): [True: 47.4k, False: 0] ------------------ _ZN17LockedPoolManager8InstanceEv: 223| 94.9k| { 224| 94.9k| static std::once_flag init_flag; 225| 94.9k| std::call_once(init_flag, LockedPoolManager::CreateInstance); 226| 94.9k| return *LockedPoolManager::_instance; 227| 94.9k| } _Z17MaybeCheckNotHeldR14AnnotatedMixinINSt3__15mutexEE: 247| 26|inline Mutex& MaybeCheckNotHeld(Mutex& cs) EXCLUSIVE_LOCKS_REQUIRED(!cs) LOCK_RETURNED(cs) { return cs; } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEEC2ERS3_PKcS7_ib: 177| 22| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 178| 22| { 179| 22| if (fTry) ------------------ | Branch (179:13): [True: 0, False: 22] ------------------ 180| 0| TryEnter(pszName, pszFile, nLine); 181| 22| else 182| 22| Enter(pszName, pszFile, nLine); 183| 22| } _Z13EnterCriticalINSt3__15mutexEEvPKcS3_iPT_b: 75| 22|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _Z13LeaveCriticalv: 76| 34|inline void LeaveCritical() {} _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEE5EnterEPKcS6_i: 157| 22| { 158| 22| 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| 22| Base::lock(); 164| 22| } _ZN10UniqueLockI14AnnotatedMixinINSt3__15mutexEEED2Ev: 197| 28| { 198| 28| if (Base::owns_lock()) ------------------ | Branch (198:13): [True: 28, False: 0] ------------------ 199| 28| LeaveCritical(); 200| 28| } _Z10DeleteLockPv: 82| 58|inline void DeleteLock(void* cs) {} _Z17MaybeCheckNotHeldI14AnnotatedMixinINSt3__115recursive_mutexEEERT_S5_: 253| 8|inline MutexType& MaybeCheckNotHeld(MutexType& m) LOCKS_EXCLUDED(m) LOCK_RETURNED(m) { return m; } _Z13EnterCriticalINSt3__115recursive_mutexEEvPKcS3_iPT_b: 75| 6|inline void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry = false) {} _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEE5EnterEPKcS6_i: 157| 6| { 158| 6| 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| 6| Base::lock(); 164| 6| } _Z22AssertLockHeldInternalI14AnnotatedMixinINSt3__15mutexEEEvPKcS5_iPT_: 79| 2|inline void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs) EXCLUSIVE_LOCKS_REQUIRED(cs) {} _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEEC2ERS3_PKcS7_ib: 177| 6| UniqueLock(MutexType& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : Base(mutexIn, std::defer_lock) 178| 6| { 179| 6| if (fTry) ------------------ | Branch (179:13): [True: 0, False: 6] ------------------ 180| 0| TryEnter(pszName, pszFile, nLine); 181| 6| else 182| 6| Enter(pszName, pszFile, nLine); 183| 6| } _ZN10UniqueLockI14AnnotatedMixinINSt3__115recursive_mutexEEED2Ev: 197| 6| { 198| 6| if (Base::owns_lock()) ------------------ | Branch (198:13): [True: 6, False: 0] ------------------ 199| 6| LeaveCritical(); 200| 6| } _ZN14AnnotatedMixinINSt3__15mutexEED2Ev: 94| 50| ~AnnotatedMixin() { 95| 50| DeleteLock((void*)this); 96| 50| } _ZN14AnnotatedMixinINSt3__115recursive_mutexEED2Ev: 94| 8| ~AnnotatedMixin() { 95| 8| DeleteLock((void*)this); 96| 8| } _ZZN10CScheduler4stopEvENKUlvE_clEv: 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ net.cpp:_ZZN8CConnman9StopNodesEvENK3$_0clEv: 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZZN11CCheckQueueI12CScriptCheckNSt3__14pairI13ScriptError_tNS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEED1EvENKUlvE_clEv: 301| 2|#define WITH_LOCK(cs, code) (MaybeCheckNotHeld(cs), [&]() -> decltype(auto) { LOCK(cs); code; }()) ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ _ZN18FuzzedDataProviderC2EPKhm: 37| 1.62k| : data_ptr_(data), remaining_bytes_(size) {} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeImEET_S1_S1_: 205| 24.9k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 24.9k| static_assert(std::is_integral::value, "An integral type is required."); 207| 24.9k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 24.9k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 24.9k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 24.9k| uint64_t range = static_cast(max) - static_cast(min); 214| 24.9k| uint64_t result = 0; 215| 24.9k| size_t offset = 0; 216| | 217| 49.7k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 49.7k, False: 0] | Branch (217:43): [True: 24.9k, False: 24.8k] ------------------ 218| 49.7k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 24.8k, False: 91] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 24.8k| --remaining_bytes_; 226| 24.8k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 24.8k| offset += CHAR_BIT; 228| 24.8k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 24.9k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 24.9k, False: 0] ------------------ 232| 24.9k| result = result % (range + 1); 233| | 234| 24.9k| return static_cast(static_cast(min) + result); 235| 24.9k|} _ZN18FuzzedDataProvider15ConsumeIntegralIjEET_v: 195| 149|template T FuzzedDataProvider::ConsumeIntegral() { 196| 149| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 149| std::numeric_limits::max()); 198| 149|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIjEET_S1_S1_: 205| 1.16k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 1.16k| static_assert(std::is_integral::value, "An integral type is required."); 207| 1.16k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 1.16k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 1.16k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 1.16k| uint64_t range = static_cast(max) - static_cast(min); 214| 1.16k| uint64_t result = 0; 215| 1.16k| size_t offset = 0; 216| | 217| 3.38k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 3.29k, False: 94] | Branch (217:43): [True: 2.40k, False: 893] ------------------ 218| 3.38k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 2.22k, False: 174] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 2.22k| --remaining_bytes_; 226| 2.22k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 2.22k| offset += CHAR_BIT; 228| 2.22k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 1.16k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 1.16k, False: 0] ------------------ 232| 1.16k| result = result % (range + 1); 233| | 234| 1.16k| return static_cast(static_cast(min) + result); 235| 1.16k|} _ZN18FuzzedDataProvider15ConsumeIntegralIhEET_v: 195| 28.7k|template T FuzzedDataProvider::ConsumeIntegral() { 196| 28.7k| return ConsumeIntegralInRange(std::numeric_limits::min(), 197| 28.7k| std::numeric_limits::max()); 198| 28.7k|} _ZN18FuzzedDataProvider22ConsumeIntegralInRangeIhEET_S1_S1_: 205| 28.7k|T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) { 206| 28.7k| static_assert(std::is_integral::value, "An integral type is required."); 207| 28.7k| static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type."); 208| | 209| 28.7k| if (min > max) ------------------ | Branch (209:7): [True: 0, False: 28.7k] ------------------ 210| 0| abort(); 211| | 212| | // Use the biggest type possible to hold the range and the result. 213| 28.7k| uint64_t range = static_cast(max) - static_cast(min); 214| 28.7k| uint64_t result = 0; 215| 28.7k| size_t offset = 0; 216| | 217| 56.3k| while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 && ------------------ | Branch (217:10): [True: 28.7k, False: 27.6k] | Branch (217:43): [True: 28.7k, False: 0] ------------------ 218| 56.3k| remaining_bytes_ != 0) { ------------------ | Branch (218:10): [True: 27.6k, False: 1.15k] ------------------ 219| | // Pull bytes off the end of the seed data. Experimentally, this seems to 220| | // allow the fuzzer to more easily explore the input space. This makes 221| | // sense, since it works by modifying inputs that caused new code to run, 222| | // and this data is often used to encode length of data read by 223| | // |ConsumeBytes|. Separating out read lengths makes it easier modify the 224| | // contents of the data that is actually read. 225| 27.6k| --remaining_bytes_; 226| 27.6k| result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_]; 227| 27.6k| offset += CHAR_BIT; 228| 27.6k| } 229| | 230| | // Avoid division by 0, in case |range + 1| results in overflow. 231| 28.7k| if (range != std::numeric_limits::max()) ------------------ | Branch (231:7): [True: 28.7k, False: 0] ------------------ 232| 28.7k| result = result % (range + 1); 233| | 234| 28.7k| return static_cast(static_cast(min) + result); 235| 28.7k|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEm: 153| 18.9k|FuzzedDataProvider::ConsumeRandomLengthString(size_t max_length) { 154| | // Reads bytes from the start of |data_ptr_|. Maps "\\" to "\", and maps "\" 155| | // followed by anything else to the end of the string. As a result of this 156| | // logic, a fuzzer can insert characters into the string, and the string 157| | // will be lengthened to include those new characters, resulting in a more 158| | // stable fuzzer than picking the length of a string independently from 159| | // picking its contents. 160| 18.9k| std::string result; 161| | 162| | // Reserve the anticipated capacity to prevent several reallocations. 163| 18.9k| result.reserve(std::min(max_length, remaining_bytes_)); 164| 24.3M| for (size_t i = 0; i < max_length && remaining_bytes_ != 0; ++i) { ------------------ | Branch (164:22): [True: 24.3M, False: 1.78k] | Branch (164:40): [True: 24.3M, False: 461] ------------------ 165| 24.3M| char next = ConvertUnsignedToSigned(data_ptr_[0]); 166| 24.3M| Advance(1); 167| 24.3M| if (next == '\\' && remaining_bytes_ != 0) { ------------------ | Branch (167:9): [True: 17.4k, False: 24.2M] | Branch (167:25): [True: 17.4k, False: 13] ------------------ 168| 17.4k| next = ConvertUnsignedToSigned(data_ptr_[0]); 169| 17.4k| Advance(1); 170| 17.4k| if (next != '\\') ------------------ | Branch (170:11): [True: 16.6k, False: 749] ------------------ 171| 16.6k| break; 172| 17.4k| } 173| 24.2M| result += next; 174| 24.2M| } 175| | 176| 18.9k| result.shrink_to_fit(); 177| 18.9k| return result; 178| 18.9k|} _ZN18FuzzedDataProvider25ConsumeRandomLengthStringEv: 181| 7.76k|inline std::string FuzzedDataProvider::ConsumeRandomLengthString() { 182| 7.76k| return ConsumeRandomLengthString(remaining_bytes_); 183| 7.76k|} _ZN18FuzzedDataProvider11ConsumeBoolEv: 289| 28.7k|inline bool FuzzedDataProvider::ConsumeBool() { 290| 28.7k| return 1 & ConsumeIntegral(); 291| 28.7k|} _ZN18FuzzedDataProvider14CopyAndAdvanceEPvm: 339| 7.68k| size_t num_bytes) { 340| 7.68k| std::memcpy(destination, data_ptr_, num_bytes); 341| 7.68k| Advance(num_bytes); 342| 7.68k|} _ZN18FuzzedDataProvider7AdvanceEm: 344| 24.3M|inline void FuzzedDataProvider::Advance(size_t num_bytes) { 345| 24.3M| if (num_bytes > remaining_bytes_) ------------------ | Branch (345:7): [True: 0, False: 24.3M] ------------------ 346| 0| abort(); 347| | 348| 24.3M| data_ptr_ += num_bytes; 349| 24.3M| remaining_bytes_ -= num_bytes; 350| 24.3M|} _ZN18FuzzedDataProvider23ConvertUnsignedToSignedIchEET_T0_: 379| 24.3M|TS FuzzedDataProvider::ConvertUnsignedToSigned(TU value) { 380| 24.3M| static_assert(sizeof(TS) == sizeof(TU), "Incompatible data types."); 381| 24.3M| static_assert(!std::numeric_limits::is_signed, 382| 24.3M| "Source type must be unsigned."); 383| | 384| | // TODO(Dor1s): change to `if constexpr` once C++17 becomes mainstream. 385| 24.3M| if (std::numeric_limits::is_modulo) ------------------ | Branch (385:7): [Folded - Ignored] ------------------ 386| 0| return static_cast(value); 387| | 388| | // Avoid using implementation-defined unsigned to signed conversions. 389| | // To learn more, see https://stackoverflow.com/questions/13150449. 390| 24.3M| if (value <= std::numeric_limits::max()) { ------------------ | Branch (390:7): [True: 23.5M, False: 820k] ------------------ 391| 23.5M| return static_cast(value); 392| 23.5M| } else { 393| 820k| constexpr auto TS_min = std::numeric_limits::min(); 394| 820k| return TS_min + static_cast(value - TS_min); 395| 820k| } 396| 24.3M|} _ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEm: 109| 7.93k|std::vector FuzzedDataProvider::ConsumeBytes(size_t num_bytes) { 110| 7.93k| num_bytes = std::min(num_bytes, remaining_bytes_); 111| 7.93k| return ConsumeBytes(num_bytes, num_bytes); 112| 7.93k|} _ZN18FuzzedDataProvider12ConsumeBytesIhEENSt3__16vectorIT_NS1_9allocatorIS3_EEEEmm: 353| 7.93k|std::vector FuzzedDataProvider::ConsumeBytes(size_t size, size_t num_bytes) { 354| 7.93k| static_assert(sizeof(T) == sizeof(uint8_t), "Incompatible data type."); 355| | 356| | // The point of using the size-based constructor below is to increase the 357| | // odds of having a vector object with capacity being equal to the length. 358| | // That part is always implementation specific, but at least both libc++ and 359| | // libstdc++ allocate the requested number of bytes in that constructor, 360| | // which seems to be a natural choice for other implementations as well. 361| | // To increase the odds even more, we also call |shrink_to_fit| below. 362| 7.93k| std::vector result(size); 363| 7.93k| if (size == 0) { ------------------ | Branch (363:7): [True: 246, False: 7.68k] ------------------ 364| 246| if (num_bytes != 0) ------------------ | Branch (364:9): [True: 0, False: 246] ------------------ 365| 0| abort(); 366| 246| return result; 367| 246| } 368| | 369| 7.68k| CopyAndAdvance(result.data(), num_bytes); 370| | 371| | // Even though |shrink_to_fit| is also implementation specific, we expect it 372| | // to provide an additional assurance in case vector's constructor allocated 373| | // a buffer which is larger than the actual amount of data we put inside it. 374| 7.68k| result.shrink_to_fit(); 375| 7.68k| return result; 376| 7.93k|} LLVMFuzzerTestOneInput: 222| 1.62k|{ 223| 1.62k| test_one_input({data, size}); 224| 1.62k| return 0; 225| 1.62k|} fuzz.cpp:_ZL14test_one_inputNSt3__14spanIKhLm18446744073709551615EEE: 83| 1.62k|{ 84| 1.62k| CheckGlobals check{}; 85| 1.62k| (*Assert(g_test_one_input))(buffer); ------------------ | | 85| 1.62k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 86| 1.62k|} _Z14ConsumeUInt256R18FuzzedDataProvider: 172| 4.41k|{ 173| 4.41k| const std::vector v256 = fuzzed_data_provider.ConsumeBytes(256 / 8); 174| 4.41k| if (v256.size() != 256 / 8) { ------------------ | Branch (174:9): [True: 201, False: 4.21k] ------------------ 175| 201| return {}; 176| 201| } 177| 4.21k| return uint256{v256}; 178| 4.41k|} _Z29ConsumeRandomLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderRKNS0_8optionalImEE: 58| 17.8k|{ 59| 17.8k| static_assert(sizeof(B) == 1); 60| 17.8k| const std::string s = max_length ? ------------------ | Branch (60:27): [True: 10.1k, False: 7.76k] ------------------ 61| 10.1k| fuzzed_data_provider.ConsumeRandomLengthString(*max_length) : 62| 17.8k| fuzzed_data_provider.ConsumeRandomLengthString(); 63| 17.8k| std::vector ret(s.size()); 64| 17.8k| std::copy(s.begin(), s.end(), reinterpret_cast(ret.data())); 65| 17.8k| return ret; 66| 17.8k|} _Z28ConsumeFixedLengthByteVectorIhENSt3__16vectorIT_NS0_9allocatorIS2_EEEER18FuzzedDataProviderm: 257| 3.51k|{ 258| 3.51k| static_assert(sizeof(B) == 1); 259| 3.51k| auto random_bytes = fuzzed_data_provider.ConsumeBytes(length); 260| 3.51k| random_bytes.resize(length); 261| 3.51k| return random_bytes; 262| 3.51k|} _Z21ConsumeDeserializableI7CPubKeyENSt3__18optionalIT_EER18FuzzedDataProviderRKNS2_ImEE: 120| 7.76k|{ 121| 7.76k| const std::vector buffer = ConsumeRandomLengthByteVector(fuzzed_data_provider, max_length); 122| 7.76k| DataStream ds{buffer}; 123| 7.76k| T obj; 124| 7.76k| try { 125| 7.76k| ds >> obj; 126| 7.76k| } catch (const std::ios_base::failure&) { 127| 403| return std::nullopt; 128| 403| } 129| 7.36k| return obj; 130| 7.76k|} crypter.cpp:_Z9CallOneOfIJZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEE3$_0ZNS1_19crypter_fuzz_targetES5_E3$_1ZNS1_19crypter_fuzz_targetES5_E3$_2ZNS1_19crypter_fuzz_targetES5_E3$_3ZNS1_19crypter_fuzz_targetES5_E3$_4ZNS1_19crypter_fuzz_targetES5_E3$_5ZNS1_19crypter_fuzz_targetES5_E3$_6EEmR18FuzzedDataProviderDpT_: 36| 24.9k|{ 37| 24.9k| constexpr size_t call_size{sizeof...(callables)}; 38| 24.9k| static_assert(call_size >= 1); 39| 24.9k| const size_t call_index{fuzzed_data_provider.ConsumeIntegralInRange(0, call_size - 1)}; 40| | 41| 24.9k| size_t i{0}; 42| 174k| ((i++ == call_index ? callables() : void()), ...); ------------------ | Branch (42:7): [True: 875, False: 24.0k] | Branch (42:7): [True: 2.75k, False: 22.1k] | Branch (42:7): [True: 4.69k, False: 20.2k] | Branch (42:7): [True: 4.40k, False: 20.5k] | Branch (42:7): [True: 916, False: 24.0k] | Branch (42:7): [True: 3.50k, False: 21.4k] | Branch (42:7): [True: 7.76k, False: 17.1k] ------------------ 43| 24.9k| return call_size; 44| 24.9k|} _ZN12CheckGlobalsC2Ev: 56| 1.62k|CheckGlobals::CheckGlobals() : m_impl(std::make_unique()) {} _ZN12CheckGlobalsD2Ev: 57| 1.62k|CheckGlobals::~CheckGlobals() = default; _ZN16CheckGlobalsImplC2Ev: 17| 1.62k| { 18| 1.62k| g_used_g_prng = false; 19| 1.62k| g_seeded_g_prng_zero = false; 20| 1.62k| g_used_system_time = false; 21| 1.62k| SetMockTime(0s); 22| 1.62k| } _ZN16CheckGlobalsImplD2Ev: 24| 1.62k| { 25| 1.62k| if (g_used_g_prng && !g_seeded_g_prng_zero) { ------------------ | Branch (25:13): [True: 0, False: 1.62k] | 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.62k| if (g_used_system_time) { ------------------ | Branch (41:13): [True: 0, False: 1.62k] ------------------ 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.62k| } _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|} _ZN17ChainTestingSetupD2Ev: 267| 2|{ 268| 2| if (m_node.scheduler) m_node.scheduler->stop(); ------------------ | Branch (268:9): [True: 2, False: 0] ------------------ 269| 2| if (m_node.validation_signals) m_node.validation_signals->FlushBackgroundCallbacks(); ------------------ | Branch (269:9): [True: 2, False: 0] ------------------ 270| 2| m_node.connman.reset(); 271| 2| m_node.banman.reset(); 272| 2| m_node.addrman.reset(); 273| 2| m_node.netgroupman.reset(); 274| 2| m_node.args = nullptr; 275| 2| m_node.mempool.reset(); 276| 2| Assert(!m_node.fee_estimator); // Each test must create a local object, if they wish to use the fee_estimator ------------------ | | 85| 2|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 277| 2| m_node.chainman.reset(); 278| 2| m_node.validation_signals.reset(); 279| 2| m_node.scheduler.reset(); 280| 2|} _ZN12StdLockGuardC2ER8StdMutex: 73| 4| explicit StdLockGuard(StdMutex& cs) EXCLUSIVE_LOCK_FUNCTION(cs) : std::lock_guard(cs) {} _ZN16TxRequestTrackerD2Ev: 725| 2|TxRequestTracker::~TxRequestTracker() = default; _ZN7uint256C2E4SpanIKhE: 208| 4.21k| constexpr explicit uint256(Span vch) : base_blob<256>(vch) {} _ZN9base_blobILj256EE4sizeEv: 121| 7.36k| static constexpr unsigned int size() { return WIDTH; } _ZN9base_blobILj256EE7SetNullEv: 56| 2| { 57| 2| std::fill(m_data.begin(), m_data.end(), 0); 58| 2| } _ZNK9base_blobILj256EE4dataEv: 112| 10.8k| constexpr const unsigned char* data() const { return m_data.data(); } _ZN9base_blobILj256EE4dataEv: 113| 7.36k| constexpr unsigned char* data() { return m_data.data(); } _ZN7uint256C2Ev: 205| 7.56k| constexpr uint256() = default; _ZN9base_blobILj256EEC2Ev: 35| 7.56k| constexpr base_blob() : m_data() {} _ZN9base_blobILj256EEC2E4SpanIKhE: 41| 4.21k| { 42| 4.21k| assert(vch.size() == WIDTH); 43| 4.21k| std::copy(vch.begin(), vch.end(), m_data.begin()); 44| 4.21k| } _Z22inline_assertion_checkILb1ERKNSt3__110unique_ptrI14LevelDBContextNS0_14default_deleteIS2_EEEEEOT0_S9_PKciSB_SB_: 52| 40|{ 53| 40| 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| 40| ) { 58| 40| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 40] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 40| } 62| 40| return std::forward(val); 63| 40|} _Z22inline_assertion_checkILb1EbEOT0_S1_PKciS3_S3_: 52| 1.62k|{ 53| 1.62k| 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.62k| ) { 58| 1.62k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.62k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.62k| } 62| 1.62k| return std::forward(val); 63| 1.62k|} _Z22inline_assertion_checkILb1ERPKNSt3__18functionIFvNS0_4spanIKhLm18446744073709551615EEEEEEEOT0_SB_PKciSD_SD_: 52| 1.62k|{ 53| 1.62k| 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.62k| ) { 58| 1.62k| if (!val) { ------------------ | Branch (58:13): [True: 0, False: 1.62k] ------------------ 59| 0| assertion_fail(file, line, func, assertion); 60| 0| } 61| 1.62k| } 62| 1.62k| return std::forward(val); 63| 1.62k|} _Z16AdditionOverflowImEbT_S0_: 16| 11.2k|{ 17| 11.2k| 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| 11.2k| return std::numeric_limits::max() - i < j; 23| 11.2k|} _Z10CheckedAddImENSt3__18optionalIT_EES2_S2_: 27| 11.2k|{ 28| 11.2k| if (AdditionOverflow(i, j)) { ------------------ | Branch (28:9): [True: 0, False: 11.2k] ------------------ 29| 0| return std::nullopt; 30| 0| } 31| 11.2k| return i + j; 32| 11.2k|} _ZN4util19TaskRunnerInterfaceD2Ev: 22| 2| virtual ~TaskRunnerInterface() = default; _ZN16CThreadInterruptclEv: 23| 4|{ 24| 4| { 25| 4| LOCK(mut); ------------------ | | 257| 4|#define LOCK(cs) UniqueLock UNIQUE_NAME(criticalblock)(MaybeCheckNotHeld(cs), #cs, __FILE__, __LINE__) | | ------------------ | | | | 11| 4|#define UNIQUE_NAME(name) PASTE2(name, __COUNTER__) | | | | ------------------ | | | | | | 9| 4|#define PASTE2(x, y) PASTE(x, y) | | | | | | ------------------ | | | | | | | | 8| 4|#define PASTE(x, y) x ## y | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 26| 4| flag.store(true, std::memory_order_release); 27| 4| } 28| 4| cond.notify_all(); 29| 4|} _ZN9NodeClock3nowEv: 27| 2|{ 28| 2| const auto mocktime{g_mock_time.load(std::memory_order_relaxed)}; 29| 2| if (!mocktime.count()) { ------------------ | Branch (29:9): [True: 2, False: 0] ------------------ 30| 2| g_used_system_time = true; 31| 2| } 32| 2| const auto ret{ 33| 2| mocktime.count() ? ------------------ | Branch (33:9): [True: 0, False: 2] ------------------ 34| 0| mocktime : 35| 2| std::chrono::system_clock::now().time_since_epoch()}; 36| 2| assert(ret > 0s); 37| 2| return time_point{ret}; 38| 2|}; _Z11SetMockTimeNSt3__16chrono8durationIxNS_5ratioILl1ELl1EEEEE: 42| 1.62k|{ 43| 1.62k| Assert(mock_time_in >= 0s); ------------------ | | 85| 1.62k|#define Assert(val) inline_assertion_check(val, __FILE__, __LINE__, __func__, #val) ------------------ 44| 1.62k| g_mock_time.store(mock_time_in, std::memory_order_relaxed); 45| 1.62k|} _Z7GetTimev: 76| 2|int64_t GetTime() { return GetTime().count(); } _Z3NowINSt3__16chrono10time_pointI9NodeClockNS1_8durationIxNS0_5ratioILl1ELl1EEEEEEEET_v: 119| 2|{ 120| 2| return std::chrono::time_point_cast(T::clock::now()); 121| 2|} _Z7GetTimeINSt3__16chrono8durationIxNS0_5ratioILl1ELl1EEEEEET_v: 125| 2|{ 126| 2| return Now>().time_since_epoch(); 127| 2|} _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|} _ZN17ChainstateManagerD2Ev: 6319| 2|{ 6320| 2| LOCK(::cs_main); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 6321| | 6322| 2| m_versionbitscache.Clear(); 6323| 2|} _ZN17ValidationSignalsD2Ev: 97| 2|ValidationSignals::~ValidationSignals() = default; _ZN17ValidationSignals24FlushBackgroundCallbacksEv: 100| 2|{ 101| 2| m_internals->m_task_runner->flush(); 102| 2|} _ZN16VersionBitsCache5ClearEv: 242| 2|{ 243| 2| LOCK(m_mutex); ------------------ | | 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 | | | | | | ------------------ | | | | ------------------ | | ------------------ ------------------ 244| 6| for (unsigned int d = 0; d < Consensus::MAX_VERSION_BITS_DEPLOYMENTS; d++) { ------------------ | Branch (244:30): [True: 4, False: 2] ------------------ 245| 4| m_caches[d].clear(); 246| 4| } 247| 2|} _ZNK6wallet8CCrypter19BytesToKeySHA512AESENSt3__14spanIKhLm18446744073709551615EEERKNS1_12basic_stringIcNS1_11char_traitsIcEE16secure_allocatorIcEEEiPhSD_: 16| 859|{ 17| | // This mimics the behavior of openssl's EVP_BytesToKey with an aes256cbc 18| | // cipher and sha512 message digest. Because sha512's output size (64b) is 19| | // greater than the aes256 block size (16b) + aes256 key size (32b), 20| | // there's no need to process more than once (D_0). 21| | 22| 859| if(!count || !key || !iv) ------------------ | Branch (22:8): [True: 0, False: 859] | Branch (22:18): [True: 0, False: 859] | Branch (22:26): [True: 0, False: 859] ------------------ 23| 0| return 0; 24| | 25| 859| unsigned char buf[CSHA512::OUTPUT_SIZE]; 26| 859| CSHA512 di; 27| | 28| 859| di.Write(UCharCast(key_data.data()), key_data.size()); 29| 859| di.Write(salt.data(), salt.size()); 30| 859| di.Finalize(buf); 31| | 32| 13.6M| for(int i = 0; i != count - 1; i++) ------------------ | Branch (32:20): [True: 13.5M, False: 859] ------------------ 33| 13.5M| di.Reset().Write(buf, sizeof(buf)).Finalize(buf); 34| | 35| 859| memcpy(key, buf, WALLET_CRYPTO_KEY_SIZE); 36| 859| memcpy(iv, buf + WALLET_CRYPTO_KEY_SIZE, WALLET_CRYPTO_IV_SIZE); 37| 859| memory_cleanse(buf, sizeof(buf)); 38| 859| return WALLET_CRYPTO_KEY_SIZE; 39| 859|} _ZN6wallet8CCrypter20SetKeyFromPassphraseERKNSt3__112basic_stringIcNS1_11char_traitsIcEE16secure_allocatorIcEEENS1_4spanIKhLm18446744073709551615EEEjj: 42| 1.01k|{ 43| 1.01k| if (rounds < 1 || salt.size() != WALLET_CRYPTO_SALT_SIZE) { ------------------ | Branch (43:9): [True: 66, False: 946] | Branch (43:23): [True: 0, False: 946] ------------------ 44| 66| return false; 45| 66| } 46| | 47| 946| int i = 0; 48| 946| if (derivation_method == 0) { ------------------ | Branch (48:9): [True: 859, False: 87] ------------------ 49| 859| i = BytesToKeySHA512AES(salt, key_data, rounds, vchKey.data(), vchIV.data()); 50| 859| } 51| | 52| 946| if (i != (int)WALLET_CRYPTO_KEY_SIZE) ------------------ | Branch (52:9): [True: 87, False: 859] ------------------ 53| 87| { 54| 87| memory_cleanse(vchKey.data(), vchKey.size()); 55| 87| memory_cleanse(vchIV.data(), vchIV.size()); 56| 87| return false; 57| 87| } 58| | 59| 859| fKeySet = true; 60| 859| return true; 61| 946|} _ZN6wallet8CCrypter6SetKeyERKNSt3__16vectorIh16secure_allocatorIhEEENS1_4spanIKhLm18446744073709551615EEE: 64| 11.7k|{ 65| 11.7k| if (new_key.size() != WALLET_CRYPTO_KEY_SIZE || new_iv.size() != WALLET_CRYPTO_IV_SIZE) { ------------------ | Branch (65:9): [True: 0, False: 11.7k] | Branch (65:53): [True: 0, False: 11.7k] ------------------ 66| 0| return false; 67| 0| } 68| | 69| 11.7k| memcpy(vchKey.data(), new_key.data(), new_key.size()); 70| 11.7k| memcpy(vchIV.data(), new_iv.data(), new_iv.size()); 71| | 72| 11.7k| fKeySet = true; 73| 11.7k| return true; 74| 11.7k|} _ZNK6wallet8CCrypter7EncryptERKNSt3__16vectorIh16secure_allocatorIhEEERNS2_IhNS1_9allocatorIhEEEE: 77| 5.60k|{ 78| 5.60k| if (!fKeySet) ------------------ | Branch (78:9): [True: 303, False: 5.30k] ------------------ 79| 303| return false; 80| | 81| | // max ciphertext len for a n bytes of plaintext is 82| | // n + AES_BLOCKSIZE bytes 83| 5.30k| vchCiphertext.resize(vchPlaintext.size() + AES_BLOCKSIZE); 84| | 85| 5.30k| AES256CBCEncrypt enc(vchKey.data(), vchIV.data(), true); 86| 5.30k| size_t nLen = enc.Encrypt(vchPlaintext.data(), vchPlaintext.size(), vchCiphertext.data()); 87| 5.30k| if(nLen < vchPlaintext.size()) ------------------ | Branch (87:8): [True: 0, False: 5.30k] ------------------ 88| 0| return false; 89| 5.30k| vchCiphertext.resize(nLen); 90| | 91| 5.30k| return true; 92| 5.30k|} _ZNK6wallet8CCrypter7DecryptENSt3__14spanIKhLm18446744073709551615EEERNS1_6vectorIh16secure_allocatorIhEEE: 95| 15.2k|{ 96| 15.2k| if (!fKeySet) ------------------ | Branch (96:9): [True: 388, False: 14.8k] ------------------ 97| 388| return false; 98| | 99| | // plaintext will always be equal to or lesser than length of ciphertext 100| 14.8k| plaintext.resize(ciphertext.size()); 101| | 102| 14.8k| AES256CBCDecrypt dec(vchKey.data(), vchIV.data(), true); 103| 14.8k| int len = dec.Decrypt(ciphertext.data(), ciphertext.size(), plaintext.data()); 104| 14.8k| if (len == 0) { ------------------ | Branch (104:9): [True: 13.3k, False: 1.49k] ------------------ 105| 13.3k| return false; 106| 13.3k| } 107| 1.49k| plaintext.resize(len); 108| 1.49k| return true; 109| 14.8k|} _ZN6wallet13EncryptSecretERKNSt3__16vectorIh16secure_allocatorIhEEES6_RK7uint256RNS1_IhNS0_9allocatorIhEEEE: 112| 916|{ 113| 916| CCrypter cKeyCrypter; 114| 916| std::vector chIV(WALLET_CRYPTO_IV_SIZE); 115| 916| memcpy(chIV.data(), &nIV, WALLET_CRYPTO_IV_SIZE); 116| 916| if(!cKeyCrypter.SetKey(vMasterKey, chIV)) ------------------ | Branch (116:8): [True: 0, False: 916] ------------------ 117| 0| return false; 118| 916| return cKeyCrypter.Encrypt(vchPlaintext, vchCiphertext); 119| 916|} _ZN6wallet13DecryptSecretERKNSt3__16vectorIh16secure_allocatorIhEEENS0_4spanIKhLm18446744073709551615EEERK7uint256RS4_: 122| 10.8k|{ 123| 10.8k| CCrypter key_crypter; 124| 10.8k| static_assert(WALLET_CRYPTO_IV_SIZE <= std::remove_reference_t::size()); 125| 10.8k| const std::span iv_prefix{iv.data(), WALLET_CRYPTO_IV_SIZE}; 126| 10.8k| if (!key_crypter.SetKey(master_key, iv_prefix)) { ------------------ | Branch (126:9): [True: 0, False: 10.8k] ------------------ 127| 0| return false; 128| 0| } 129| 10.8k| return key_crypter.Decrypt(ciphertext, plaintext); 130| 10.8k|} _ZN6wallet10DecryptKeyERKNSt3__16vectorIh16secure_allocatorIhEEENS0_4spanIKhLm18446744073709551615EEERK7CPubKeyR4CKey: 133| 7.36k|{ 134| 7.36k| CKeyingMaterial secret; 135| 7.36k| if (!DecryptSecret(master_key, crypted_secret, pub_key.GetHash(), secret)) { ------------------ | Branch (135:9): [True: 7.24k, False: 124] ------------------ 136| 7.24k| return false; 137| 7.24k| } 138| | 139| 124| if (secret.size() != 32) { ------------------ | Branch (139:9): [True: 124, False: 0] ------------------ 140| 124| return false; 141| 124| } 142| | 143| 0| key.Set(secret.begin(), secret.end(), pub_key.IsCompressed()); 144| 0| return key.VerifyPubKey(pub_key); 145| 124|} _ZN6wallet8CCrypter8CleanKeyEv: 87| 13.4k| { 88| 13.4k| memory_cleanse(vchKey.data(), vchKey.size()); 89| 13.4k| memory_cleanse(vchIV.data(), vchIV.size()); 90| 13.4k| fKeySet = false; 91| 13.4k| } _ZN6wallet8CCrypterC2Ev: 94| 13.4k| { 95| 13.4k| fKeySet = false; 96| 13.4k| vchKey.resize(WALLET_CRYPTO_KEY_SIZE); 97| 13.4k| vchIV.resize(WALLET_CRYPTO_IV_SIZE); 98| 13.4k| } _ZN6wallet8CCrypterD2Ev: 101| 13.4k| { 102| 13.4k| CleanKey(); 103| 13.4k| } crypter.cpp:_ZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEE: 22| 1.62k|{ 23| 1.62k| FuzzedDataProvider fuzzed_data_provider(buffer.data(), buffer.size()); 24| 1.62k| bool good_data{true}; 25| | 26| 1.62k| CCrypter crypt; 27| | // These values are regularly updated within `CallOneOf` 28| 1.62k| std::vector cipher_text_ed; 29| 1.62k| CKeyingMaterial plain_text_ed; 30| 1.62k| const std::vector random_key = ConsumeFixedLengthByteVector(fuzzed_data_provider, WALLET_CRYPTO_KEY_SIZE); 31| | 32| 1.62k| if (fuzzed_data_provider.ConsumeBool()) { ------------------ | Branch (32:9): [True: 1.01k, False: 612] ------------------ 33| 1.01k| const std::string random_string = fuzzed_data_provider.ConsumeRandomLengthString(100); 34| 1.01k| SecureString secure_string(random_string.begin(), random_string.end()); 35| | 36| 1.01k| const unsigned int derivation_method = fuzzed_data_provider.ConsumeBool() ? 0 : fuzzed_data_provider.ConsumeIntegral(); ------------------ | Branch (36:48): [True: 863, False: 149] ------------------ 37| | 38| | // Limiting the value of rounds since it is otherwise uselessly expensive and causes a timeout when fuzzing. 39| 1.01k| crypt.SetKeyFromPassphrase(/*key_data=*/secure_string, 40| 1.01k| /*salt=*/ConsumeFixedLengthByteVector(fuzzed_data_provider, WALLET_CRYPTO_SALT_SIZE), 41| 1.01k| /*rounds=*/fuzzed_data_provider.ConsumeIntegralInRange(0, 25000), 42| 1.01k| /*derivation_method=*/derivation_method); 43| 1.01k| } 44| | 45| 1.62k| LIMITED_WHILE(good_data && fuzzed_data_provider.ConsumeBool(), 100) ------------------ | | 23| 52.6k| for (unsigned _count{limit}; (condition) && _count; --_count) | | ------------------ | | | Branch (23:35): [True: 26.1k, False: 403] | | | Branch (23:35): [True: 24.9k, False: 1.19k] | | | Branch (23:49): [True: 24.9k, False: 26] | | ------------------ ------------------ 46| 24.9k| { 47| 24.9k| CallOneOf( 48| 24.9k| fuzzed_data_provider, 49| 24.9k| [&] { 50| 24.9k| const std::vector random_vector = ConsumeFixedLengthByteVector(fuzzed_data_provider, WALLET_CRYPTO_KEY_SIZE); 51| 24.9k| plain_text_ed = CKeyingMaterial(random_vector.begin(), random_vector.end()); 52| 24.9k| }, 53| 24.9k| [&] { 54| 24.9k| cipher_text_ed = ConsumeRandomLengthByteVector(fuzzed_data_provider, 64); 55| 24.9k| }, 56| 24.9k| [&] { 57| 24.9k| (void)crypt.Encrypt(plain_text_ed, cipher_text_ed); 58| 24.9k| }, 59| 24.9k| [&] { 60| 24.9k| (void)crypt.Decrypt(cipher_text_ed, plain_text_ed); 61| 24.9k| }, 62| 24.9k| [&] { 63| 24.9k| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 64| 24.9k| const uint256 iv = ConsumeUInt256(fuzzed_data_provider); 65| 24.9k| (void)EncryptSecret(master_key, plain_text_ed, iv, cipher_text_ed); 66| 24.9k| }, 67| 24.9k| [&] { 68| 24.9k| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 69| 24.9k| const uint256 iv = ConsumeUInt256(fuzzed_data_provider); 70| 24.9k| (void)DecryptSecret(master_key, cipher_text_ed, iv, plain_text_ed); 71| 24.9k| }, 72| 24.9k| [&] { 73| 24.9k| std::optional random_pub_key = ConsumeDeserializable(fuzzed_data_provider); 74| 24.9k| if (!random_pub_key) { 75| 24.9k| good_data = false; 76| 24.9k| return; 77| 24.9k| } 78| 24.9k| const CPubKey pub_key = *random_pub_key; 79| 24.9k| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 80| 24.9k| const std::vector crypted_secret = ConsumeRandomLengthByteVector(fuzzed_data_provider, 64); 81| 24.9k| CKey key; 82| 24.9k| (void)DecryptKey(master_key, crypted_secret, pub_key, key); 83| 24.9k| }); 84| 24.9k| } 85| 1.62k|} crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_0clEv: 49| 875| [&] { 50| 875| const std::vector random_vector = ConsumeFixedLengthByteVector(fuzzed_data_provider, WALLET_CRYPTO_KEY_SIZE); 51| 875| plain_text_ed = CKeyingMaterial(random_vector.begin(), random_vector.end()); 52| 875| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_1clEv: 53| 2.75k| [&] { 54| 2.75k| cipher_text_ed = ConsumeRandomLengthByteVector(fuzzed_data_provider, 64); 55| 2.75k| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_2clEv: 56| 4.69k| [&] { 57| 4.69k| (void)crypt.Encrypt(plain_text_ed, cipher_text_ed); 58| 4.69k| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_3clEv: 59| 4.40k| [&] { 60| 4.40k| (void)crypt.Decrypt(cipher_text_ed, plain_text_ed); 61| 4.40k| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_4clEv: 62| 916| [&] { 63| 916| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 64| 916| const uint256 iv = ConsumeUInt256(fuzzed_data_provider); 65| 916| (void)EncryptSecret(master_key, plain_text_ed, iv, cipher_text_ed); 66| 916| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_5clEv: 67| 3.50k| [&] { 68| 3.50k| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 69| 3.50k| const uint256 iv = ConsumeUInt256(fuzzed_data_provider); 70| 3.50k| (void)DecryptSecret(master_key, cipher_text_ed, iv, plain_text_ed); 71| 3.50k| }, crypter.cpp:_ZZN6wallet12_GLOBAL__N_119crypter_fuzz_targetENSt3__14spanIKhLm18446744073709551615EEEENK3$_6clEv: 72| 7.76k| [&] { 73| 7.76k| std::optional random_pub_key = ConsumeDeserializable(fuzzed_data_provider); 74| 7.76k| if (!random_pub_key) { ------------------ | Branch (74:21): [True: 403, False: 7.36k] ------------------ 75| 403| good_data = false; 76| 403| return; 77| 403| } 78| 7.36k| const CPubKey pub_key = *random_pub_key; 79| 7.36k| const CKeyingMaterial master_key(random_key.begin(), random_key.end()); 80| 7.36k| const std::vector crypted_secret = ConsumeRandomLengthByteVector(fuzzed_data_provider, 64); 81| 7.36k| CKey key; 82| 7.36k| (void)DecryptKey(master_key, crypted_secret, pub_key, key); 83| 7.36k| });