[llvm] [Support] FIx a warning (PR #138546)
via llvm-commits
llvm-commits at lists.llvm.org
Mon May 5 08:47:49 PDT 2025
github-actions[bot] wrote:
<!--LLVM CODE FORMAT COMMENT: {clang-format}-->
:warning: C/C++ code formatter, clang-format found issues in your code. :warning:
<details>
<summary>
You can test this locally with the following command:
</summary>
``````````bash
git-clang-format --diff HEAD~1 HEAD --extensions h -- llvm/include/llvm/Support/Error.h llvm/include/llvm/Support/ErrorHandling.h
``````````
</details>
<details>
<summary>
View the diff from clang-format here.
</summary>
``````````diff
diff --git a/llvm/include/llvm/Support/ErrorHandling.h b/llvm/include/llvm/Support/ErrorHandling.h
index 63f456f74..afea23b6a 100644
--- a/llvm/include/llvm/Support/ErrorHandling.h
+++ b/llvm/include/llvm/Support/ErrorHandling.h
@@ -59,89 +59,89 @@ namespace llvm {
~ScopedFatalErrorHandler() { remove_fatal_error_handler(); }
};
-/// report_fatal_error below has been soft deprecated.
-/// Use reportFatalInternalError() or reportFatalUsageError() instead.
-[[noreturn]] void report_fatal_error(const char *reason,
- bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(StringRef reason,
- bool gen_crash_diag = true);
-[[noreturn]] void report_fatal_error(const Twine &reason,
- bool gen_crash_diag = true);
-
-/// Report a fatal error that likely indicates a bug in LLVM. It serves a
-/// similar purpose as an assertion, but is always enabled, regardless of the
-/// value of NDEBUG.
-///
-/// This will call installed error handlers (or print the message by default)
-/// and then abort. This will produce a crash trace and *will* ask users to
-/// report an LLVM bug.
-[[noreturn]] void reportFatalInternalError(const char *reason);
-[[noreturn]] void reportFatalInternalError(StringRef reason);
-[[noreturn]] void reportFatalInternalError(const Twine &reason);
-
-/// Report a fatal error that does not indicate a bug in LLVM.
-///
-/// This can be used in contexts where a proper error reporting mechanism
-/// (such as Error/Expected or DiagnosticInfo) is currently not supported, and
-/// would be too involved to introduce at the moment.
-///
-/// Examples where this function should be used instead of
-/// reportFatalInternalError() include invalid inputs or options, but also
-/// environment error conditions outside LLVM's control. It should also be used
-/// for known unsupported/unimplemented functionality.
-///
-/// This will call installed error handlers (or print the message by default)
-/// and then exit with code 1. It will not produce a crash trace and will
-/// *not* ask users to report an LLVM bug.
-[[noreturn]] void reportFatalUsageError(const char *reason);
-[[noreturn]] void reportFatalUsageError(StringRef reason);
-[[noreturn]] void reportFatalUsageError(const Twine &reason);
-
-/// Installs a new bad alloc error handler that should be used whenever a
-/// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM.
-///
-/// The user can install a bad alloc handler, in order to define the behavior
-/// in case of failing allocations, e.g. throwing an exception. Note that this
-/// handler must not trigger any additional allocations itself.
-///
-/// If no error handler is installed the default is to print the error message
-/// to stderr, and call exit(1). If an error handler is installed then it is
-/// the handler's responsibility to log the message, it will no longer be
-/// printed to stderr. If the error handler returns, then exit(1) will be
-/// called.
-///
-///
-/// \param user_data - An argument which will be passed to the installed error
-/// handler.
-void install_bad_alloc_error_handler(fatal_error_handler_t handler,
- void *user_data = nullptr);
+ /// report_fatal_error below has been soft deprecated.
+ /// Use reportFatalInternalError() or reportFatalUsageError() instead.
+ [[noreturn]] void report_fatal_error(const char *reason,
+ bool gen_crash_diag = true);
+ [[noreturn]] void report_fatal_error(StringRef reason,
+ bool gen_crash_diag = true);
+ [[noreturn]] void report_fatal_error(const Twine &reason,
+ bool gen_crash_diag = true);
+
+ /// Report a fatal error that likely indicates a bug in LLVM. It serves a
+ /// similar purpose as an assertion, but is always enabled, regardless of the
+ /// value of NDEBUG.
+ ///
+ /// This will call installed error handlers (or print the message by default)
+ /// and then abort. This will produce a crash trace and *will* ask users to
+ /// report an LLVM bug.
+ [[noreturn]] void reportFatalInternalError(const char *reason);
+ [[noreturn]] void reportFatalInternalError(StringRef reason);
+ [[noreturn]] void reportFatalInternalError(const Twine &reason);
+
+ /// Report a fatal error that does not indicate a bug in LLVM.
+ ///
+ /// This can be used in contexts where a proper error reporting mechanism
+ /// (such as Error/Expected or DiagnosticInfo) is currently not supported, and
+ /// would be too involved to introduce at the moment.
+ ///
+ /// Examples where this function should be used instead of
+ /// reportFatalInternalError() include invalid inputs or options, but also
+ /// environment error conditions outside LLVM's control. It should also be
+ /// used for known unsupported/unimplemented functionality.
+ ///
+ /// This will call installed error handlers (or print the message by default)
+ /// and then exit with code 1. It will not produce a crash trace and will
+ /// *not* ask users to report an LLVM bug.
+ [[noreturn]] void reportFatalUsageError(const char *reason);
+ [[noreturn]] void reportFatalUsageError(StringRef reason);
+ [[noreturn]] void reportFatalUsageError(const Twine &reason);
+
+ /// Installs a new bad alloc error handler that should be used whenever a
+ /// bad alloc error, e.g. failing malloc/calloc, is encountered by LLVM.
+ ///
+ /// The user can install a bad alloc handler, in order to define the behavior
+ /// in case of failing allocations, e.g. throwing an exception. Note that this
+ /// handler must not trigger any additional allocations itself.
+ ///
+ /// If no error handler is installed the default is to print the error message
+ /// to stderr, and call exit(1). If an error handler is installed then it is
+ /// the handler's responsibility to log the message, it will no longer be
+ /// printed to stderr. If the error handler returns, then exit(1) will be
+ /// called.
+ ///
+ ///
+ /// \param user_data - An argument which will be passed to the installed error
+ /// handler.
+ void install_bad_alloc_error_handler(fatal_error_handler_t handler,
+ void *user_data = nullptr);
-/// Restores default bad alloc error handling behavior.
-void remove_bad_alloc_error_handler();
+ /// Restores default bad alloc error handling behavior.
+ void remove_bad_alloc_error_handler();
-void install_out_of_memory_new_handler();
+ void install_out_of_memory_new_handler();
-/// Reports a bad alloc error, calling any user defined bad alloc
-/// error handler. In contrast to the generic 'report_fatal_error'
-/// functions, this function might not terminate, e.g. the user
-/// defined error handler throws an exception, but it won't return.
-///
-/// Note: When throwing an exception in the bad alloc handler, make sure that
-/// the following unwind succeeds, e.g. do not trigger additional allocations
-/// in the unwind chain.
-///
-/// If no error handler is installed (default), throws a bad_alloc exception
-/// if LLVM is compiled with exception support. Otherwise prints the error
-/// to standard error and calls abort().
-[[noreturn]] void report_bad_alloc_error(const char *Reason,
- bool GenCrashDiag = true);
-
-/// This function calls abort(), and prints the optional message to stderr.
-/// Use the llvm_unreachable macro (that adds location info), instead of
-/// calling this function directly.
-[[noreturn]] void
-llvm_unreachable_internal(const char *msg = nullptr, const char *file = nullptr,
- unsigned line = 0);
+ /// Reports a bad alloc error, calling any user defined bad alloc
+ /// error handler. In contrast to the generic 'report_fatal_error'
+ /// functions, this function might not terminate, e.g. the user
+ /// defined error handler throws an exception, but it won't return.
+ ///
+ /// Note: When throwing an exception in the bad alloc handler, make sure that
+ /// the following unwind succeeds, e.g. do not trigger additional allocations
+ /// in the unwind chain.
+ ///
+ /// If no error handler is installed (default), throws a bad_alloc exception
+ /// if LLVM is compiled with exception support. Otherwise prints the error
+ /// to standard error and calls abort().
+ [[noreturn]] void report_bad_alloc_error(const char *Reason,
+ bool GenCrashDiag = true);
+
+ /// This function calls abort(), and prints the optional message to stderr.
+ /// Use the llvm_unreachable macro (that adds location info), instead of
+ /// calling this function directly.
+ [[noreturn]] void llvm_unreachable_internal(const char *msg = nullptr,
+ const char *file = nullptr,
+ unsigned line = 0);
}
/// Marks that the current location is not supposed to be reachable.
``````````
</details>
https://github.com/llvm/llvm-project/pull/138546
More information about the llvm-commits
mailing list