mirror/bitcoin
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

util: Allow Assert() in contexts without __func__

Browse Source 
Without this, compile warnings could be hit about __func__ being only
valid inside functions.

warning: predefined identifier is only valid inside function [-Wpredefined-identifier-outside-function]
note: expanded from macro Assert
  115 | #define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val)
      |                                                                           ^

Ref https://github.com/bitcoin/bitcoin/pull/32740#discussion_r2486258473
This commit is contained in:
MarcoFalke committed 2025-11-05 08:42:24 +01:00
1 parent 33389f1144
commit fa5fbcd615
2 files changed
+25 -22
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/util/check.cpp
+10 -8
View File
@@ -1,4 +1,4 @@
// Copyright (c) 2022 The Bitcoin Core developers // Copyright (c) 2022-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying // Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -11,30 +11,32 @@
#include <cstdio> #include <cstdio>
#include <cstdlib> #include <cstdlib>
#include <source_location>
#include <string> #include <string>
#include <string_view> #include <string_view>
std::string StrFormatInternalBug(std::string_view msg, std::string_view file, int line, std::string_view func) std::string StrFormatInternalBug(std::string_view msg, const std::source_location& loc)
{ {
return strprintf("Internal bug detected: %s\n%s:%d (%s)\n" return strprintf("Internal bug detected: %s\n%s:%d (%s)\n"
"%s %s\n" "%s %s\n"
"Please report this issue here: %s\n", "Please report this issue here: %s\n",
msg, file, line, func, CLIENT_NAME, FormatFullVersion(), CLIENT_BUGREPORT); msg, loc.file_name(), loc.line(), loc.function_name(),
CLIENT_NAME, FormatFullVersion(), CLIENT_BUGREPORT);
} }
NonFatalCheckError::NonFatalCheckError(std::string_view msg, std::string_view file, int line, std::string_view func) NonFatalCheckError::NonFatalCheckError(std::string_view msg, const std::source_location& loc)
: std::runtime_error{StrFormatInternalBug(msg, file, line, func)} : std::runtime_error{StrFormatInternalBug(msg, loc)}
{ {
} }
bool g_detail_test_only_CheckFailuresAreExceptionsNotAborts{false}; bool g_detail_test_only_CheckFailuresAreExceptionsNotAborts{false};
void assertion_fail(std::string_view file, int line, std::string_view func, std::string_view assertion) void assertion_fail(const std::source_location& loc, std::string_view assertion)
{ {
if (g_detail_test_only_CheckFailuresAreExceptionsNotAborts) { if (g_detail_test_only_CheckFailuresAreExceptionsNotAborts) {
throw NonFatalCheckError{assertion, file, line, func}; throw NonFatalCheckError{assertion, loc};
} }
auto str = strprintf("%s:%s %s: Assertion `%s' failed.\n", file, line, func, assertion); auto str = strprintf("%s:%s %s: Assertion `%s' failed.\n", loc.file_name(), loc.line(), loc.function_name(), assertion);
fwrite(str.data(), 1, str.size(), stderr); fwrite(str.data(), 1, str.size(), stderr);
std::abort(); std::abort();
} }
src/util/check.h
+15 -14
View File
@@ -1,4 +1,4 @@
// Copyright (c) 2019-2022 The Bitcoin Core developers // Copyright (c) 2019-present The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying // Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php. // file COPYING or http://www.opensource.org/licenses/mit-license.php.
@@ -9,6 +9,7 @@
#include <atomic> #include <atomic>
#include <cassert> // IWYU pragma: export #include <cassert> // IWYU pragma: export
#include <source_location>
#include <stdexcept> #include <stdexcept>
#include <string> #include <string>
#include <string_view> #include <string_view>
@@ -52,26 +53,26 @@ struct test_only_CheckFailuresAreExceptionsNotAborts {
~test_only_CheckFailuresAreExceptionsNotAborts() { g_detail_test_only_CheckFailuresAreExceptionsNotAborts = false; }; ~test_only_CheckFailuresAreExceptionsNotAborts() { g_detail_test_only_CheckFailuresAreExceptionsNotAborts = false; };
}; };
std::string StrFormatInternalBug(std::string_view msg, std::string_view file, int line, std::string_view func); std::string StrFormatInternalBug(std::string_view msg, const std::source_location& loc);
class NonFatalCheckError : public std::runtime_error class NonFatalCheckError : public std::runtime_error
{ {
public: public:
NonFatalCheckError(std::string_view msg, std::string_view file, int line, std::string_view func); NonFatalCheckError(std::string_view msg, const std::source_location& loc);
}; };
/** Internal helper */ /** Internal helper */
void assertion_fail(std::string_view file, int line, std::string_view func, std::string_view assertion); void assertion_fail(const std::source_location& loc, std::string_view assertion);
/** Helper for CHECK_NONFATAL() */ /** Helper for CHECK_NONFATAL() */
template <typename T> template <typename T>
T&& inline_check_non_fatal(LIFETIMEBOUND T&& val, const char* file, int line, const char* func, const char* assertion) T&& inline_check_non_fatal(LIFETIMEBOUND T&& val, std::source_location loc, std::string_view assertion)
{ {
if (!val) { if (!val) {
if constexpr (G_ABORT_ON_FAILED_ASSUME) { if constexpr (G_ABORT_ON_FAILED_ASSUME) {
assertion_fail(file, line, func, assertion); assertion_fail(loc, assertion);
} }
throw NonFatalCheckError{assertion, file, line, func}; throw NonFatalCheckError{assertion, loc};
} }
return std::forward<T>(val); return std::forward<T>(val);
} }
@@ -82,11 +83,11 @@ T&& inline_check_non_fatal(LIFETIMEBOUND T&& val, const char* file, int line, co
/** Helper for Assert()/Assume() */ /** Helper for Assert()/Assume() */
template <bool IS_ASSERT, typename T> template <bool IS_ASSERT, typename T>
constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] const char* file, [[maybe_unused]] int line, [[maybe_unused]] const char* func, [[maybe_unused]] const char* assertion) constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] std::source_location loc, [[maybe_unused]] std::string_view assertion)
{ {
if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) { if (IS_ASSERT || std::is_constant_evaluated() || G_ABORT_ON_FAILED_ASSUME) {
if (!val) { if (!val) {
assertion_fail(file, line, func, assertion); assertion_fail(loc, assertion);
} }
} }
return std::forward<T>(val); return std::forward<T>(val);
@@ -95,7 +96,7 @@ constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] con
// All macros may use __func__ inside a lambda, so put them under nolint. // All macros may use __func__ inside a lambda, so put them under nolint.
// NOLINTBEGIN(bugprone-lambda-function-name) // NOLINTBEGIN(bugprone-lambda-function-name)
#define STR_INTERNAL_BUG(msg) StrFormatInternalBug((msg), __FILE__, __LINE__, __func__) #define STR_INTERNAL_BUG(msg) StrFormatInternalBug((msg), std::source_location::current())
/** /**
* Identity function. Throw a NonFatalCheckError when the condition evaluates to false * Identity function. Throw a NonFatalCheckError when the condition evaluates to false
@@ -109,10 +110,10 @@ constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] con
* caller, which can then report the issue to the developers. * caller, which can then report the issue to the developers.
*/ */
#define CHECK_NONFATAL(condition) \ #define CHECK_NONFATAL(condition) \
inline_check_non_fatal(condition, __FILE__, __LINE__, __func__, #condition) inline_check_non_fatal(condition, std::source_location::current(), #condition)
/** Identity function. Abort if the value compares equal to zero */ /** Identity function. Abort if the value compares equal to zero */
#define Assert(val) inline_assertion_check<true>(val, __FILE__, __LINE__, __func__, #val) #define Assert(val) inline_assertion_check<true>(val, std::source_location::current(), #val)
/** /**
* Assume is the identity function. * Assume is the identity function.
@@ -124,14 +125,14 @@ constexpr T&& inline_assertion_check(LIFETIMEBOUND T&& val, [[maybe_unused]] con
* - For non-fatal errors in interactive sessions (e.g. RPC or command line * - For non-fatal errors in interactive sessions (e.g. RPC or command line
* interfaces), CHECK_NONFATAL() might be more appropriate. * interfaces), CHECK_NONFATAL() might be more appropriate.
*/ */
#define Assume(val) inline_assertion_check<false>(val, __FILE__, __LINE__, __func__, #val) #define Assume(val) inline_assertion_check<false>(val, std::source_location::current(), #val)
/** /**
* NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code. It throws a NonFatalCheckError. * NONFATAL_UNREACHABLE() is a macro that is used to mark unreachable code. It throws a NonFatalCheckError.
*/ */
#define NONFATAL_UNREACHABLE() \ #define NONFATAL_UNREACHABLE() \
throw NonFatalCheckError( \ throw NonFatalCheckError( \
"Unreachable code reached (non-fatal)", __FILE__, __LINE__, __func__) "Unreachable code reached (non-fatal)", std::source_location::current())
// NOLINTEND(bugprone-lambda-function-name) // NOLINTEND(bugprone-lambda-function-name)