Coverage Report

Created: 2026-05-30 09:47

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/tmp/bitcoin/src/util/check.h
Line
Count
Source
1
// Copyright (c) 2019-present The Bitcoin Core developers
2
// Distributed under the MIT software license, see the accompanying
3
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5
#ifndef BITCOIN_UTIL_CHECK_H
6
#define BITCOIN_UTIL_CHECK_H
7
8
#include <attributes.h>
9
10
#include <atomic>
11
// We use `util/check.h` to provide the `assert()` macro
12
// to ensure that `NDEBUG` is not defined.
13
#include <cassert> // IWYU pragma: export
14
#include <source_location>
15
#include <stdexcept>
16
#include <string>
17
#include <string_view>
18
#include <type_traits>
19
#include <utility>
20
21
constexpr bool G_FUZZING_BUILD{
22
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
23
    true
24
#else
25
    false
26
#endif
27
};
28
constexpr bool G_ABORT_ON_FAILED_ASSUME{G_FUZZING_BUILD ||
29
#ifdef ABORT_ON_FAILED_ASSUME
30
    true
31
#else
32
    false
33
#endif
34
};
35
36
extern std::atomic<bool> g_enable_dynamic_fuzz_determinism;
37
38
inline bool EnableFuzzDeterminism()
39
1.61M
{
40
    if constexpr (G_FUZZING_BUILD) {
41
        return true;
42
    } else if constexpr (!G_ABORT_ON_FAILED_ASSUME) {
43
        // Running fuzz tests is always disabled if Assume() doesn't abort
44
        // (ie, non-fuzz non-debug builds), as otherwise tests which
45
        // should fail due to a failing Assume may still pass. As such,
46
        // we also statically disable fuzz determinism in that case.
47
        return false;
48
1.61M
    } else {
49
1.61M
        return g_enable_dynamic_fuzz_determinism;
50
1.61M
    }
51
1.61M
}
52
53
extern bool g_detail_test_only_CheckFailuresAreExceptionsNotAborts;
54
struct test_only_CheckFailuresAreExceptionsNotAborts {
55
2
    test_only_CheckFailuresAreExceptionsNotAborts() { g_detail_test_only_CheckFailuresAreExceptionsNotAborts = true; };
56
2
    ~test_only_CheckFailuresAreExceptionsNotAborts() { g_detail_test_only_CheckFailuresAreExceptionsNotAborts = false; };
57
};
58
59
std::string StrFormatInternalBug(std::string_view msg, const std::source_location& loc);
60
61
class NonFatalCheckError : public std::runtime_error
62
{
63
public:
64
    NonFatalCheckError(std::string_view msg, const std::source_location& loc);
65
};
66
67
/** Internal helper */
68
void assertion_fail(const std::source_location& loc, std::string_view assertion);
69
70
/** Helper for CHECK_NONFATAL() */
71
template <typename T>
72
T&& inline_check_non_fatal(LIFETIMEBOUND T&& val, const std::source_location& loc, std::string_view assertion)
73
277M
{
74
277M
    if (!val) {
75
9
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
9
            assertion_fail(loc, assertion);
77
9
        }
78
9
        throw NonFatalCheckError{assertion, loc};
79
9
    }
80
277M
    return std::forward<T>(val);
81
277M
}
bool const& inline_check_non_fatal<bool const&>(bool const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
103
{
74
103
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
103
    return std::forward<T>(val);
81
103
}
bool&& inline_check_non_fatal<bool>(bool&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
269M
{
74
269M
    if (!val) {
75
9
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
9
            assertion_fail(loc, assertion);
77
9
        }
78
9
        throw NonFatalCheckError{assertion, loc};
79
9
    }
80
269M
    return std::forward<T>(val);
81
269M
}
bool& inline_check_non_fatal<bool&>(bool&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
7.67M
{
74
7.67M
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
7.67M
    return std::forward<T>(val);
81
7.67M
}
ValidationSignals* const& inline_check_non_fatal<ValidationSignals* const&>(ValidationSignals* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
13.7k
{
74
13.7k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
13.7k
    return std::forward<T>(val);
81
13.7k
}
CBlockIndex const*&& inline_check_non_fatal<CBlockIndex const*>(CBlockIndex const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
141k
{
74
141k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
141k
    return std::forward<T>(val);
81
141k
}
CBlockIndex const*& inline_check_non_fatal<CBlockIndex const*&>(CBlockIndex const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
127
{
74
127
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
127
    return std::forward<T>(val);
81
127
}
std::unique_ptr<CCoinsViewCursor, std::default_delete<CCoinsViewCursor>>&& inline_check_non_fatal<std::unique_ptr<CCoinsViewCursor, std::default_delete<CCoinsViewCursor>>>(std::unique_ptr<CCoinsViewCursor, std::default_delete<CCoinsViewCursor>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
1.07k
{
74
1.07k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
1.07k
    return std::forward<T>(val);
81
1.07k
}
node::BlockManager*&& inline_check_non_fatal<node::BlockManager*>(node::BlockManager*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
11
{
74
11
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
11
    return std::forward<T>(val);
81
11
}
Unexecuted instantiation: std::shared_ptr<CTransaction const>&& inline_check_non_fatal<std::shared_ptr<CTransaction const>>(std::shared_ptr<CTransaction const>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
CBlockIndex*& inline_check_non_fatal<CBlockIndex*&>(CBlockIndex*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
2.08k
{
74
2.08k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
2.08k
    return std::forward<T>(val);
81
2.08k
}
std::optional<interfaces::BlockRef>&& inline_check_non_fatal<std::optional<interfaces::BlockRef>>(std::optional<interfaces::BlockRef>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
2.10k
{
74
2.10k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
2.10k
    return std::forward<T>(val);
81
2.10k
}
std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>& inline_check_non_fatal<std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>&>(std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
4.01k
{
74
4.01k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
4.01k
    return std::forward<T>(val);
81
4.01k
}
CBlockIndex*&& inline_check_non_fatal<CBlockIndex*>(CBlockIndex*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
16.5k
{
74
16.5k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
16.5k
    return std::forward<T>(val);
81
16.5k
}
CBlockIndex* const& inline_check_non_fatal<CBlockIndex* const&>(CBlockIndex* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
11
{
74
11
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
11
    return std::forward<T>(val);
81
11
}
std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>& inline_check_non_fatal<std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>&>(std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
16.2k
{
74
16.2k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
16.2k
    return std::forward<T>(val);
81
16.2k
}
std::optional<kernel::CCoinsStats>& inline_check_non_fatal<std::optional<kernel::CCoinsStats>&>(std::optional<kernel::CCoinsStats>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
37
{
74
37
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
37
    return std::forward<T>(val);
81
37
}
std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>> const& inline_check_non_fatal<std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>> const&>(std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
141
{
74
141
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
141
    return std::forward<T>(val);
81
141
}
std::optional<CFeeRate> const& inline_check_non_fatal<std::optional<CFeeRate> const&>(std::optional<CFeeRate> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
24
{
74
24
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
24
    return std::forward<T>(val);
81
24
}
std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>& inline_check_non_fatal<std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>&>(std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
36.5k
{
74
36.5k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
36.5k
    return std::forward<T>(val);
81
36.5k
}
std::unique_ptr<CScheduler, std::default_delete<CScheduler>> const& inline_check_non_fatal<std::unique_ptr<CScheduler, std::default_delete<CScheduler>> const&>(std::unique_ptr<CScheduler, std::default_delete<CScheduler>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
12
{
74
12
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
12
    return std::forward<T>(val);
81
12
}
std::optional<CMutableTransaction>&& inline_check_non_fatal<std::optional<CMutableTransaction>>(std::optional<CMutableTransaction>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
45
{
74
45
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
45
    return std::forward<T>(val);
81
45
}
std::function<bool ()>& inline_check_non_fatal<std::function<bool ()>&>(std::function<bool ()>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
974
{
74
974
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
974
    return std::forward<T>(val);
81
974
}
wallet::DescriptorScriptPubKeyMan*& inline_check_non_fatal<wallet::DescriptorScriptPubKeyMan*&>(wallet::DescriptorScriptPubKeyMan*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
278
{
74
278
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
278
    return std::forward<T>(val);
81
278
}
JSONRPCRequest const*& inline_check_non_fatal<JSONRPCRequest const*&>(JSONRPCRequest const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
35.6k
{
74
35.6k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
35.6k
    return std::forward<T>(val);
81
35.6k
}
UniValue const*& inline_check_non_fatal<UniValue const*&>(UniValue const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
32.8k
{
74
32.8k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
32.8k
    return std::forward<T>(val);
81
32.8k
}
std::optional<arith_uint256>&& inline_check_non_fatal<std::optional<arith_uint256>>(std::optional<arith_uint256>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
73
19.6k
{
74
19.6k
    if (!val) {
75
0
        if constexpr (G_ABORT_ON_FAILED_ASSUME) {
76
0
            assertion_fail(loc, assertion);
77
0
        }
78
0
        throw NonFatalCheckError{assertion, loc};
79
0
    }
80
19.6k
    return std::forward<T>(val);
81
19.6k
}
82
83
#if defined(NDEBUG)
84
#error "Cannot compile without assertions!"
85
#endif
86
87
/** Helper for Assert()/Assume() */
88
template <bool IS_ASSERT, typename T>
89
constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] const std::source_location& loc, [[maybe_unused]] std::string_view assertion)
90
2.64G
{
91
2.64G
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2.64G
        if (!val) {
93
2
            assertion_fail(loc, assertion);
94
2
        }
95
2.64G
    }
96
2.64G
    return std::forward<T>(val);
97
2.64G
}
bool&& inline_assertion_check<false, bool>(bool&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2.51G
{
91
2.51G
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2.51G
        if (!val) {
93
1
            assertion_fail(loc, assertion);
94
1
        }
95
2.51G
    }
96
2.51G
    return std::forward<T>(val);
97
2.51G
}
bool&& inline_assertion_check<true, bool>(bool&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
14.9M
{
91
14.9M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
14.9M
        if (!val) {
93
1
            assertion_fail(loc, assertion);
94
1
        }
95
14.9M
    }
96
14.9M
    return std::forward<T>(val);
97
14.9M
}
std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>>& inline_assertion_check<true, std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>>&>(std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
849k
{
91
849k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
849k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
849k
    }
96
849k
    return std::forward<T>(val);
97
849k
}
std::unique_ptr<LevelDBContext, std::default_delete<LevelDBContext>> const& inline_assertion_check<true, std::unique_ptr<LevelDBContext, std::default_delete<LevelDBContext>> const&>(std::unique_ptr<LevelDBContext, std::default_delete<LevelDBContext>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
12.6M
{
91
12.6M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
12.6M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
12.6M
    }
96
12.6M
    return std::forward<T>(val);
97
12.6M
}
int&& inline_assertion_check<false, int>(int&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
56.1M
{
91
56.1M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
56.1M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
56.1M
    }
96
56.1M
    return std::forward<T>(val);
97
56.1M
}
unsigned char const& inline_assertion_check<false, unsigned char const&>(unsigned char const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.22M
{
91
1.22M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.22M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.22M
    }
96
1.22M
    return std::forward<T>(val);
97
1.22M
}
CCoinsView*& inline_assertion_check<true, CCoinsView*&>(CCoinsView*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
414k
{
91
414k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
414k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
414k
    }
96
414k
    return std::forward<T>(val);
97
414k
}
std::unique_ptr<CoinsViews, std::default_delete<CoinsViews>>& inline_assertion_check<true, std::unique_ptr<CoinsViews, std::default_delete<CoinsViews>>&>(std::unique_ptr<CoinsViews, std::default_delete<CoinsViews>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2.06M
{
91
2.06M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2.06M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2.06M
    }
96
2.06M
    return std::forward<T>(val);
97
2.06M
}
std::unique_ptr<CCoinsViewCache, std::default_delete<CCoinsViewCache>>& inline_assertion_check<true, std::unique_ptr<CCoinsViewCache, std::default_delete<CCoinsViewCache>>&>(std::unique_ptr<CCoinsViewCache, std::default_delete<CCoinsViewCache>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2.06M
{
91
2.06M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2.06M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2.06M
    }
96
2.06M
    return std::forward<T>(val);
97
2.06M
}
std::optional<arith_uint256> const& inline_assertion_check<true, std::optional<arith_uint256> const&>(std::optional<arith_uint256> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
220k
{
91
220k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
220k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
220k
    }
96
220k
    return std::forward<T>(val);
97
220k
}
std::optional<uint256> const& inline_assertion_check<true, std::optional<uint256> const&>(std::optional<uint256> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
160k
{
91
160k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
160k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
160k
    }
96
160k
    return std::forward<T>(val);
97
160k
}
std::unique_ptr<CTxMemPool, std::default_delete<CTxMemPool>>& inline_assertion_check<true, std::unique_ptr<CTxMemPool, std::default_delete<CTxMemPool>>&>(std::unique_ptr<CTxMemPool, std::default_delete<CTxMemPool>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
24
{
91
24
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
24
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
24
    }
96
24
    return std::forward<T>(val);
97
24
}
std::optional<uint256>&& inline_assertion_check<true, std::optional<uint256>>(std::optional<uint256>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
131
{
91
131
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
131
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
131
    }
96
131
    return std::forward<T>(val);
97
131
}
std::function<bool ()>& inline_assertion_check<true, std::function<bool ()>&>(std::function<bool ()>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.29k
{
91
1.29k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.29k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.29k
    }
96
1.29k
    return std::forward<T>(val);
97
1.29k
}
std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>& inline_assertion_check<true, std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>&>(std::unique_ptr<node::Warnings, std::default_delete<node::Warnings>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.29k
{
91
1.29k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.29k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.29k
    }
96
1.29k
    return std::forward<T>(val);
97
1.29k
}
util::SignalInterrupt*& inline_assertion_check<true, util::SignalInterrupt*&>(util::SignalInterrupt*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
81.1k
{
91
81.1k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
81.1k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
81.1k
    }
96
81.1k
    return std::forward<T>(val);
97
81.1k
}
node::ReadRawError*&& inline_assertion_check<true, node::ReadRawError*>(node::ReadRawError*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
14
{
91
14
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
14
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
14
    }
96
14
    return std::forward<T>(val);
97
14
}
unsigned long& inline_assertion_check<false, unsigned long&>(unsigned long&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
17.5M
{
91
17.5M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
17.5M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
17.5M
    }
96
17.5M
    return std::forward<T>(val);
97
17.5M
}
Unexecuted instantiation: unsigned long const& inline_assertion_check<false, unsigned long const&>(unsigned long const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
std::optional<unsigned int>&& inline_assertion_check<true, std::optional<unsigned int>>(std::optional<unsigned int>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3
{
91
3
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3
    }
96
3
    return std::forward<T>(val);
97
3
}
CBlockIndex*&& inline_assertion_check<true, CBlockIndex*>(CBlockIndex*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
119k
{
91
119k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
119k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
119k
    }
96
119k
    return std::forward<T>(val);
97
119k
}
std::optional<BCLog::LogFlags>&& inline_assertion_check<true, std::optional<BCLog::LogFlags>>(std::optional<BCLog::LogFlags>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
31
{
91
31
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
31
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
31
    }
96
31
    return std::forward<T>(val);
97
31
}
std::shared_ptr<BCLog::LogRateLimiter>& inline_assertion_check<true, std::shared_ptr<BCLog::LogRateLimiter>&>(std::shared_ptr<BCLog::LogRateLimiter>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1
{
91
1
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1
    }
96
1
    return std::forward<T>(val);
97
1
}
CBlockIndex*& inline_assertion_check<true, CBlockIndex*&>(CBlockIndex*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
306k
{
91
306k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
306k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
306k
    }
96
306k
    return std::forward<T>(val);
97
306k
}
CTxMemPoolEntry const*&& inline_assertion_check<true, CTxMemPoolEntry const*>(CTxMemPoolEntry const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
109
{
91
109
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
109
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
109
    }
96
109
    return std::forward<T>(val);
97
109
}
ArgsManager*& inline_assertion_check<true, ArgsManager*&>(ArgsManager*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
10.0k
{
91
10.0k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
10.0k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
10.0k
    }
96
10.0k
    return std::forward<T>(val);
97
10.0k
}
std::optional<std::vector<std::byte, std::allocator<std::byte>>>&& inline_assertion_check<true, std::optional<std::vector<std::byte, std::allocator<std::byte>>>>(std::optional<std::vector<std::byte, std::allocator<std::byte>>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3.73k
{
91
3.73k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3.73k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3.73k
    }
96
3.73k
    return std::forward<T>(val);
97
3.73k
}
unsigned long const& inline_assertion_check<true, unsigned long const&>(unsigned long const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
4
{
91
4
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
4
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
4
    }
96
4
    return std::forward<T>(val);
97
4
}
util::Expected<std::future<void>, ThreadPool::SubmitError>&& inline_assertion_check<true, util::Expected<std::future<void>, ThreadPool::SubmitError>>(util::Expected<std::future<void>, ThreadPool::SubmitError>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
351
{
91
351
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
351
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
351
    }
96
351
    return std::forward<T>(val);
97
351
}
ThreadPool::SubmitError*&& inline_assertion_check<true, ThreadPool::SubmitError*>(ThreadPool::SubmitError*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
5
{
91
5
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
5
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
5
    }
96
5
    return std::forward<T>(val);
97
5
}
ThreadPool::SubmitError const*&& inline_assertion_check<true, ThreadPool::SubmitError const*>(ThreadPool::SubmitError const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
util::Expected<std::future<bool>, ThreadPool::SubmitError>&& inline_assertion_check<true, util::Expected<std::future<bool>, ThreadPool::SubmitError>>(util::Expected<std::future<bool>, ThreadPool::SubmitError>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
util::Expected<std::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ThreadPool::SubmitError>&& inline_assertion_check<true, util::Expected<std::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ThreadPool::SubmitError>>(util::Expected<std::future<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, ThreadPool::SubmitError>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1
{
91
1
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1
    }
96
1
    return std::forward<T>(val);
97
1
}
util::Expected<std::vector<std::future<int>, std::allocator<std::future<int>>>, ThreadPool::SubmitError>&& inline_assertion_check<true, util::Expected<std::vector<std::future<int>, std::allocator<std::future<int>>>, ThreadPool::SubmitError>>(util::Expected<std::vector<std::future<int>, std::allocator<std::future<int>>>, ThreadPool::SubmitError>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&& inline_assertion_check<true, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*&& inline_assertion_check<true, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
4
{
91
4
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
4
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
4
    }
96
4
    return std::forward<T>(val);
97
4
}
std::unique_ptr<int, std::default_delete<int>>*&& inline_assertion_check<true, std::unique_ptr<int, std::default_delete<int>>*>(std::unique_ptr<int, std::default_delete<int>>*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3
{
91
3
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3
    }
96
3
    return std::forward<T>(val);
97
3
}
std::unique_ptr<int, std::default_delete<int>>&& inline_assertion_check<true, std::unique_ptr<int, std::default_delete<int>>>(std::unique_ptr<int, std::default_delete<int>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
std::unique_ptr<int, std::default_delete<int>> const& inline_assertion_check<true, std::unique_ptr<int, std::default_delete<int>> const&>(std::unique_ptr<int, std::default_delete<int>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
bool const& inline_assertion_check<true, bool const&>(bool const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
util_tests.cpp:util_tests::(anonymous namespace)::NoCopyOrMove& inline_assertion_check<true, util_tests::(anonymous namespace)::NoCopyOrMove&>(util_tests::(anonymous namespace)::NoCopyOrMove&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
6
{
91
6
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
6
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
6
    }
96
6
    return std::forward<T>(val);
97
6
}
int&& inline_assertion_check<true, int>(int&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
Unexecuted instantiation: std::optional<int>&& inline_assertion_check<true, std::optional<int>>(std::optional<int>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Chainstate*&& inline_assertion_check<true, Chainstate*>(Chainstate*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7
{
91
7
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7
    }
96
7
    return std::forward<T>(val);
97
7
}
std::optional<uint256> const&& inline_assertion_check<true, std::optional<uint256> const>(std::optional<uint256> const&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
4
{
91
4
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
4
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
4
    }
96
4
    return std::forward<T>(val);
97
4
}
std::unique_ptr<wallet::WalletDatabase, std::default_delete<wallet::WalletDatabase>> const& inline_assertion_check<true, std::unique_ptr<wallet::WalletDatabase, std::default_delete<wallet::WalletDatabase>> const&>(std::unique_ptr<wallet::WalletDatabase, std::default_delete<wallet::WalletDatabase>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
std::unique_ptr<wallet::SQLiteDatabase, std::default_delete<wallet::SQLiteDatabase>> const& inline_assertion_check<true, std::unique_ptr<wallet::SQLiteDatabase, std::default_delete<wallet::SQLiteDatabase>> const&>(std::unique_ptr<wallet::SQLiteDatabase, std::default_delete<wallet::SQLiteDatabase>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
util::Result<std::variant<CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown>>&& inline_assertion_check<true, util::Result<std::variant<CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown>>>(util::Result<std::variant<CNoDestination, PubKeyDestination, PKHash, ScriptHash, WitnessV0ScriptHash, WitnessV0KeyHash, WitnessV1Taproot, PayToAnchor, WitnessUnknown>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
6.11k
{
91
6.11k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
6.11k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
6.11k
    }
96
6.11k
    return std::forward<T>(val);
97
6.11k
}
util::Result<wallet::CoinsResult>&& inline_assertion_check<true, util::Result<wallet::CoinsResult>>(util::Result<wallet::CoinsResult>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1
{
91
1
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1
    }
96
1
    return std::forward<T>(val);
97
1
}
std::optional<OutputType>&& inline_assertion_check<true, std::optional<OutputType>>(std::optional<OutputType>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
124
{
91
124
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
124
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
124
    }
96
124
    return std::forward<T>(val);
97
124
}
util::Result<std::reference_wrapper<wallet::DescriptorScriptPubKeyMan>>&& inline_assertion_check<true, util::Result<std::reference_wrapper<wallet::DescriptorScriptPubKeyMan>>>(util::Result<std::reference_wrapper<wallet::DescriptorScriptPubKeyMan>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
27
{
91
27
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
27
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
27
    }
96
27
    return std::forward<T>(val);
97
27
}
Unexecuted instantiation: std::atomic<bool>& inline_assertion_check<true, std::atomic<bool>&>(std::atomic<bool>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
CTxMemPool*&& inline_assertion_check<true, CTxMemPool*>(CTxMemPool*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.19k
{
91
1.19k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.19k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.19k
    }
96
1.19k
    return std::forward<T>(val);
97
1.19k
}
util::Result<node::BlockCreateOptions>& inline_assertion_check<true, util::Result<node::BlockCreateOptions>&>(util::Result<node::BlockCreateOptions>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.20k
{
91
1.20k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.20k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.20k
    }
96
1.20k
    return std::forward<T>(val);
97
1.20k
}
std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>& inline_assertion_check<true, std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>&>(std::unique_ptr<interfaces::BlockTemplate, std::default_delete<interfaces::BlockTemplate>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7.02k
{
91
7.02k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7.02k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7.02k
    }
96
7.02k
    return std::forward<T>(val);
97
7.02k
}
util::Result<void> const& inline_assertion_check<true, util::Result<void> const&>(util::Result<void> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
169
{
91
169
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
169
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
169
    }
96
169
    return std::forward<T>(val);
97
169
}
std::optional<PresaltedSipHasher>& inline_assertion_check<true, std::optional<PresaltedSipHasher>&>(std::optional<PresaltedSipHasher>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
150k
{
91
150k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
150k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
150k
    }
96
150k
    return std::forward<T>(val);
97
150k
}
CBlockIndex const*&& inline_assertion_check<true, CBlockIndex const*>(CBlockIndex const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
9.24k
{
91
9.24k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
9.24k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
9.24k
    }
96
9.24k
    return std::forward<T>(val);
97
9.24k
}
evhttp_connection*&& inline_assertion_check<true, evhttp_connection*>(evhttp_connection*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
343k
{
91
343k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
343k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
343k
    }
96
343k
    return std::forward<T>(val);
97
343k
}
evhttp_request*& inline_assertion_check<true, evhttp_request*&>(evhttp_request*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
343k
{
91
343k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
343k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
343k
    }
96
343k
    return std::forward<T>(val);
97
343k
}
evhttp_connection const*& inline_assertion_check<true, evhttp_connection const*&>(evhttp_connection const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3.07k
{
91
3.07k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3.07k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3.07k
    }
96
3.07k
    return std::forward<T>(val);
97
3.07k
}
CBlockIndex const*& inline_assertion_check<true, CBlockIndex const*&>(CBlockIndex const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
133k
{
91
133k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
133k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
133k
    }
96
133k
    return std::forward<T>(val);
97
133k
}
CBlock const* const& inline_assertion_check<true, CBlock const* const&>(CBlock const* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7.54k
{
91
7.54k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7.54k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7.54k
    }
96
7.54k
    return std::forward<T>(val);
97
7.54k
}
CBlockUndo const* const& inline_assertion_check<true, CBlockUndo const* const&>(CBlockUndo const* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7.90k
{
91
7.90k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7.90k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7.90k
    }
96
7.90k
    return std::forward<T>(val);
97
7.90k
}
uint256 const* const& inline_assertion_check<true, uint256 const* const&>(uint256 const* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
189k
{
91
189k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
189k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
189k
    }
96
189k
    return std::forward<T>(val);
97
189k
}
std::optional<util::SignalInterrupt>& inline_assertion_check<true, std::optional<util::SignalInterrupt>&>(std::optional<util::SignalInterrupt>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
22
{
91
22
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
22
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
22
    }
96
22
    return std::forward<T>(val);
97
22
}
util::Result<void>&& inline_assertion_check<true, util::Result<void>>(util::Result<void>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3.14k
{
91
3.14k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3.14k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3.14k
    }
96
3.14k
    return std::forward<T>(val);
97
3.14k
}
std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>& inline_assertion_check<true, std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>&>(std::unique_ptr<ValidationSignals, std::default_delete<ValidationSignals>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.97k
{
91
1.97k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.97k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.97k
    }
96
1.97k
    return std::forward<T>(val);
97
1.97k
}
std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>>& inline_assertion_check<true, std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>>&>(std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.02k
{
91
1.02k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.02k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.02k
    }
96
1.02k
    return std::forward<T>(val);
97
1.02k
}
bool& inline_assertion_check<false, bool&>(bool&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
423k
{
91
423k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
423k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
423k
    }
96
423k
    return std::forward<T>(val);
97
423k
}
net_processing.cpp:(anonymous namespace)::CNodeState*&& inline_assertion_check<true, (anonymous namespace)::CNodeState*>((anonymous namespace)::CNodeState*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
55.9k
{
91
55.9k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
55.9k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
55.9k
    }
96
55.9k
    return std::forward<T>(val);
97
55.9k
}
net_processing.cpp:std::shared_ptr<(anonymous namespace)::Peer>&& inline_assertion_check<true, std::shared_ptr<(anonymous namespace)::Peer>>(std::shared_ptr<(anonymous namespace)::Peer>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
4
{
91
4
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
4
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
4
    }
96
4
    return std::forward<T>(val);
97
4
}
CBlockIndex*&& inline_assertion_check<false, CBlockIndex*>(CBlockIndex*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
16.4k
{
91
16.4k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
16.4k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
16.4k
    }
96
16.4k
    return std::forward<T>(val);
97
16.4k
}
std::optional<AssumeutxoData> const& inline_assertion_check<true, std::optional<AssumeutxoData> const&>(std::optional<AssumeutxoData> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
6
{
91
6
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
6
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
6
    }
96
6
    return std::forward<T>(val);
97
6
}
std::optional<node::BlockfileCursor>& inline_assertion_check<true, std::optional<node::BlockfileCursor>&>(std::optional<node::BlockfileCursor>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
106k
{
91
106k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
106k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
106k
    }
96
106k
    return std::forward<T>(val);
97
106k
}
std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>> const& inline_assertion_check<true, std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>> const&>(std::unique_ptr<node::KernelNotifications, std::default_delete<node::KernelNotifications>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
52.7k
{
91
52.7k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
52.7k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
52.7k
    }
96
52.7k
    return std::forward<T>(val);
97
52.7k
}
util::SignalInterrupt* const& inline_assertion_check<true, util::SignalInterrupt* const&>(util::SignalInterrupt* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7.99k
{
91
7.99k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7.99k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7.99k
    }
96
7.99k
    return std::forward<T>(val);
97
7.99k
}
Unexecuted instantiation: node::NodeContext*& inline_assertion_check<true, node::NodeContext*&>(node::NodeContext*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Unexecuted instantiation: node::NodeContext*&& inline_assertion_check<true, node::NodeContext*>(node::NodeContext*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Unexecuted instantiation: interfaces::WalletLoader*& inline_assertion_check<true, interfaces::WalletLoader*&>(interfaces::WalletLoader*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>> const& inline_assertion_check<true, std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>> const&>(std::unique_ptr<ChainstateManager, std::default_delete<ChainstateManager>> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
93.9k
{
91
93.9k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
93.9k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
93.9k
    }
96
93.9k
    return std::forward<T>(val);
97
93.9k
}
std::optional<unsigned long> const& inline_assertion_check<true, std::optional<unsigned long> const&>(std::optional<unsigned long> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
44.7k
{
91
44.7k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
44.7k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
44.7k
    }
96
44.7k
    return std::forward<T>(val);
97
44.7k
}
std::optional<uint256> const& inline_assertion_check<false, std::optional<uint256> const&>(std::optional<uint256> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
69
{
91
69
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
69
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
69
    }
96
69
    return std::forward<T>(val);
97
69
}
std::optional<uint256>&& inline_assertion_check<false, std::optional<uint256>>(std::optional<uint256>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
44.7k
{
91
44.7k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
44.7k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
44.7k
    }
96
44.7k
    return std::forward<T>(val);
97
44.7k
}
bool const& inline_assertion_check<false, bool const&>(bool const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
513k
{
91
513k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
513k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
513k
    }
96
513k
    return std::forward<T>(val);
97
513k
}
node::ReadRawError const*&& inline_assertion_check<true, node::ReadRawError const*>(node::ReadRawError const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
12
{
91
12
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
12
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
12
    }
96
12
    return std::forward<T>(val);
97
12
}
unsigned int&& inline_assertion_check<false, unsigned int>(unsigned int&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
21.3M
{
91
21.3M
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
21.3M
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
21.3M
    }
96
21.3M
    return std::forward<T>(val);
97
21.3M
}
TxGraph::Ref const*& inline_assertion_check<false, TxGraph::Ref const*&>(TxGraph::Ref const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2.73k
{
91
2.73k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2.73k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2.73k
    }
96
2.73k
    return std::forward<T>(val);
97
2.73k
}
txgraph.cpp:(anonymous namespace)::Cluster*& inline_assertion_check<false, (anonymous namespace)::Cluster*&>((anonymous namespace)::Cluster*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
168k
{
91
168k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
168k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
168k
    }
96
168k
    return std::forward<T>(val);
97
168k
}
Unexecuted instantiation: std::unique_ptr<CTxMemPool::ChangeSet, std::default_delete<CTxMemPool::ChangeSet>>& inline_assertion_check<false, std::unique_ptr<CTxMemPool::ChangeSet, std::default_delete<CTxMemPool::ChangeSet>>&>(std::unique_ptr<CTxMemPool::ChangeSet, std::default_delete<CTxMemPool::ChangeSet>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
std::shared_ptr<CBlock const>& inline_assertion_check<true, std::shared_ptr<CBlock const>&>(std::shared_ptr<CBlock const>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
106k
{
91
106k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
106k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
106k
    }
96
106k
    return std::forward<T>(val);
97
106k
}
uint256 const*& inline_assertion_check<true, uint256 const*&>(uint256 const*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
45.3k
{
91
45.3k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
45.3k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
45.3k
    }
96
45.3k
    return std::forward<T>(val);
97
45.3k
}
std::optional<int> const& inline_assertion_check<true, std::optional<int> const&>(std::optional<int> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
416k
{
91
416k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
416k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
416k
    }
96
416k
    return std::forward<T>(val);
97
416k
}
CBlockIndex* const& inline_assertion_check<false, CBlockIndex* const&>(CBlockIndex* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
305k
{
91
305k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
305k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
305k
    }
96
305k
    return std::forward<T>(val);
97
305k
}
std::unique_ptr<Chainstate, std::default_delete<Chainstate>>&& inline_assertion_check<true, std::unique_ptr<Chainstate, std::default_delete<Chainstate>>>(std::unique_ptr<Chainstate, std::default_delete<Chainstate>>&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
std::unique_ptr<util::TaskRunnerInterface, std::default_delete<util::TaskRunnerInterface>>& inline_assertion_check<true, std::unique_ptr<util::TaskRunnerInterface, std::default_delete<util::TaskRunnerInterface>>&>(std::unique_ptr<util::TaskRunnerInterface, std::default_delete<util::TaskRunnerInterface>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
1.28k
{
91
1.28k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
1.28k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
1.28k
    }
96
1.28k
    return std::forward<T>(val);
97
1.28k
}
std::optional<long> const& inline_assertion_check<true, std::optional<long> const&>(std::optional<long> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3.75k
{
91
3.75k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3.75k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3.75k
    }
96
3.75k
    return std::forward<T>(val);
97
3.75k
}
CScheduler*& inline_assertion_check<true, CScheduler*&>(CScheduler*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
7
{
91
7
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
7
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
7
    }
96
7
    return std::forward<T>(val);
97
7
}
wallet::CWalletTx const*&& inline_assertion_check<true, wallet::CWalletTx const*>(wallet::CWalletTx const*&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
5
{
91
5
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
5
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
5
    }
96
5
    return std::forward<T>(val);
97
5
}
std::unique_ptr<wallet::SQliteExecHandler, std::default_delete<wallet::SQliteExecHandler>>& inline_assertion_check<true, std::unique_ptr<wallet::SQliteExecHandler, std::default_delete<wallet::SQliteExecHandler>>&>(std::unique_ptr<wallet::SQliteExecHandler, std::default_delete<wallet::SQliteExecHandler>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
146k
{
91
146k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
146k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
146k
    }
96
146k
    return std::forward<T>(val);
97
146k
}
unsigned long&& inline_assertion_check<true, unsigned long>(unsigned long&&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
624
{
91
624
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
624
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
624
    }
96
624
    return std::forward<T>(val);
97
624
}
ArgsManager* const& inline_assertion_check<true, ArgsManager* const&>(ArgsManager* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
962
{
91
962
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
962
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
962
    }
96
962
    return std::forward<T>(val);
97
962
}
wallet::LegacyDataSPKM*& inline_assertion_check<false, wallet::LegacyDataSPKM*&>(wallet::LegacyDataSPKM*&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
72
{
91
72
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
72
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
72
    }
96
72
    return std::forward<T>(val);
97
72
}
std::shared_ptr<CTransaction const>& inline_assertion_check<true, std::shared_ptr<CTransaction const>&>(std::shared_ptr<CTransaction const>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
2
{
91
2
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
2
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
2
    }
96
2
    return std::forward<T>(val);
97
2
}
bool& inline_assertion_check<true, bool&>(bool&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
402
{
91
402
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
402
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
402
    }
96
402
    return std::forward<T>(val);
97
402
}
std::optional<fs::path> const& inline_assertion_check<true, std::optional<fs::path> const&>(std::optional<fs::path> const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
3.43k
{
91
3.43k
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
3.43k
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
3.43k
    }
96
3.43k
    return std::forward<T>(val);
97
3.43k
}
std::optional<std::pair<XOnlyPubKey, bool>>& inline_assertion_check<false, std::optional<std::pair<XOnlyPubKey, bool>>&>(std::optional<std::pair<XOnlyPubKey, bool>>&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
516
{
91
516
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
516
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
516
    }
96
516
    return std::forward<T>(val);
97
516
}
std::map<uint256, MuSig2SecNonce, std::less<uint256>, std::allocator<std::pair<uint256 const, MuSig2SecNonce>>>* const& inline_assertion_check<false, std::map<uint256, MuSig2SecNonce, std::less<uint256>, std::allocator<std::pair<uint256 const, MuSig2SecNonce>>>* const&>(std::map<uint256, MuSig2SecNonce, std::less<uint256>, std::allocator<std::pair<uint256 const, MuSig2SecNonce>>>* const&, std::source_location const&, std::basic_string_view<char, std::char_traits<char>>)
Line
Count
Source
90
276
{
91
276
    if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
92
276
        if (!val) {
93
0
            assertion_fail(loc, assertion);
94
0
        }
95
276
    }
96
276
    return std::forward<T>(val);
97
276
}
98
99
0
#define STR_INTERNAL_BUG(msg) StrFormatInternalBug((msg), std::source_location::current())
100
101
/**
102
 * Identity function. Throw a NonFatalCheckError when the condition evaluates to false
103
 *
104
 * This should only be used
105
 * - where the condition is assumed to be true, not for error handling or validating user input
106
 * - where a failure to fulfill the condition is recoverable and does not abort the program
107
 *
108
 * For example in RPC code, where it is undesirable to crash the whole program, this can be generally used to replace
109
 * asserts or recoverable logic errors. A NonFatalCheckError in RPC code is caught and passed as a string to the RPC
110
 * caller, which can then report the issue to the developers.
111
 */
112
#define CHECK_NONFATAL(condition) \
113
277M
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
blockchain.cpp:GetUTXOStats(CCoinsView*, node::BlockManager&, kernel::CoinStatsHashType, std::function<void ()> const&, CBlockIndex const*, bool)::$_0::operator()() const
Line
Count
Source
113
18
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
blockchain.cpp:gettxoutsetinfo()::$_0::operator()(RPCMethod const&, JSONRPCRequest const&) const::'lambda'()::operator()() const
Line
Count
Source
113
32
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
blockchain.cpp:scanblocks()::$_0::operator()(RPCMethod const&, JSONRPCRequest const&) const::'lambda0'()::operator()() const
Line
Count
Source
113
3
    inline_check_non_fatal(condition, std::source_location::current(), #condition)
114
115
/** Identity function. Abort if the value compares equal to zero */
116
35.9M
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
validation_chainstate_tests.cpp:validation_chainstate_tests::chainstate_update_tip::test_method()::$_2::operator()() const
Line
Count
Source
116
1
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
validation_chainstate_tests.cpp:bool CreateAndActivateUTXOSnapshot<$_4>(TestingSetup*, $_4, bool, bool)::'lambda0'()::operator()() const
Line
Count
Source
116
1
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<$_37 const>(TestingSetup*, $_37 const, bool, bool)::'lambda0'()::operator()() const
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda'(AutoFile&, node::SnapshotMetadata&)>(TestingSetup*, validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda'(AutoFile&, node::SnapshotMetadata&), bool, bool)::'lambda0'()::operator()() const
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda0'(AutoFile&, node::SnapshotMetadata&)>(TestingSetup*, validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda0'(AutoFile&, node::SnapshotMetadata&), bool, bool)::'lambda0'()::operator()() const
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda1'(AutoFile&, node::SnapshotMetadata&)>(TestingSetup*, validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda1'(AutoFile&, node::SnapshotMetadata&), bool, bool)::'lambda0'()::operator()() const
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda2'(AutoFile&, node::SnapshotMetadata&)>(TestingSetup*, validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda2'(AutoFile&, node::SnapshotMetadata&), bool, bool)::'lambda0'()::operator()() const
Unexecuted instantiation: validation_chainstatemanager_tests.cpp:bool CreateAndActivateUTXOSnapshot<validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda3'(AutoFile&, node::SnapshotMetadata&)>(TestingSetup*, validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda3'(AutoFile&, node::SnapshotMetadata&), bool, bool)::'lambda0'()::operator()() const
validation_chainstatemanager_tests::SnapshotTestSetup::SetupSnapshot()::'lambda0'()::operator()() const
Line
Count
Source
116
4
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
validation_chainstatemanager_tests.cpp:validation_chainstatemanager_tests::chainstatemanager_snapshot_completion::test_method()::$_0::operator()() const
Line
Count
Source
116
1
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
Unexecuted instantiation: txmempool.cpp:CheckMempoolEphemeralInvariants(CTxMemPool const&)::$_0::operator()(CTxIn const&) const
blockstorage.cpp:node::BlockManager::WriteBlockUndo(CBlockUndo const&, BlockValidationState&, CBlockIndex&)::$_0::operator()() const
Line
Count
Source
116
106k
#define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
117
118
/**
119
 * Assume is the identity function.
120
 *
121
 * - Should be used to run non-fatal checks. In debug builds it behaves like
122
 *   Assert()/assert() to notify developers and testers about non-fatal errors.
123
 *   In production it doesn't warn or log anything.
124
 * - For fatal errors, use Assert().
125
 * - For non-fatal errors in interactive sessions (e.g. RPC or command line
126
 *   interfaces), CHECK_NONFATAL() might be more appropriate.
127
 */
128
2.61G
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
net_processing.cpp:(anonymous namespace)::PeerManagerImpl::ProcessMessage((anonymous namespace)::Peer&, CNode&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, DataStream&, std::chrono::time_point<NodeClock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>>, std::atomic<bool> const&)::$_2::operator()() const
Line
Count
Source
128
4.43k
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
mini_miner.cpp:_ZZNK4node9MiniMiner11SanityCheckEvENK3$_0clISt17_Rb_tree_iteratorISt4pairIK22transaction_identifierILb0EENS_21MiniMinerMempoolEntryEEEEEDaRKT_
Line
Count
Source
128
3.39M
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
mini_miner.cpp:_ZZNK4node9MiniMiner11SanityCheckEvENK3$_1clI22transaction_identifierILb0EEEEDaRKT_
Line
Count
Source
128
406
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
ephemeral_policy.cpp:_ZZ20CheckEphemeralSpendsRKSt6vectorISt10shared_ptrIK12CTransactionESaIS3_EE8CFeeRateRK10CTxMemPoolR17TxValidationStateR22transaction_identifierILb1EEENK3$_0clIS3_EEDaRKT_
Line
Count
Source
128
31.0k
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
validation.cpp:_ZZN17ChainstateManager25ReceivedBlockTransactionsERK6CBlockP11CBlockIndexRK11FlatFilePosENK3$_0clISt10unique_ptrI10ChainstateSt14default_deleteISB_EEEEDaRKT_
Line
Count
Source
128
2
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
scriptpubkeyman.cpp:wallet::DescriptorScriptPubKeyMan::GetKey(CKeyID const&) const::$_0::operator()(std::vector<unsigned char, secure_allocator<unsigned char>> const&) const
Line
Count
Source
128
9
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
wallet.cpp:wallet::CWallet::GetScriptPubKeyMans(CScript const&) const::$_0::operator()(wallet::ScriptPubKeyMan*) const
Line
Count
Source
128
112k
#define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
129
130
/**
131
 * NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code. It throws a NonFatalCheckError.
132
 */
133
#define NONFATAL_UNREACHABLE() \
134
0
    throw NonFatalCheckError { "Unreachable code reached (non-fatal)", std::source_location::current() }
135
136
#if defined(__has_feature)
137
#    if __has_feature(address_sanitizer)
138
#       include <sanitizer/asan_interface.h>
139
#    endif
140
#endif
141
142
#ifndef ASAN_POISON_MEMORY_REGION
143
95.4M
#   define ASAN_POISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
144
160M
#   define ASAN_UNPOISON_MEMORY_REGION(addr, size) ((void)(addr), (void)(size))
145
#endif
146
147
#endif // BITCOIN_UTIL_CHECK_H