[llvm] [llvm] annotate interfaces in llvm/Support for DLL export (PR #136014)

[Nikita Popov via llvm-commits]

================
@@ -61,87 +61,87 @@ namespace llvm {
 
 /// @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);
+  [[noreturn]] LLVM_ABI void report_fatal_error(const char *reason,
+                                                bool gen_crash_diag = true);
+  [[noreturn]] LLVM_ABI void report_fatal_error(StringRef reason,
+                                                bool gen_crash_diag = true);
+  [[noreturn]] LLVM_ABI 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]] LLVM_ABI void reportFatalInternalError(const char *reason);
+  [[noreturn]] LLVM_ABI void reportFatalInternalError(StringRef reason);
+  [[noreturn]] LLVM_ABI 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]] LLVM_ABI void reportFatalUsageError(const char *reason);
+  [[noreturn]] LLVM_ABI void reportFatalUsageError(StringRef reason);
+  [[noreturn]] LLVM_ABI 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.
+  LLVM_ABI 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.
+  LLVM_ABI void remove_bad_alloc_error_handler();
 
-void install_out_of_memory_new_handler();
+  LLVM_ABI 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]] LLVM_ABI 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]] LLVM_ABI void
+  llvm_unreachable_internal(const char *msg = nullptr,
+                            const char *file = nullptr, unsigned line = 0);
----------------
nikic wrote:

Should drop this big indent change. (Or reformat the whole file ahead of time -- it's the code above this that's formatted incorrectly, not this code.)

https://github.com/llvm/llvm-project/pull/136014