From 59c57531741dc7a3813269d60b97eadb63109960 Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Wed, 7 Apr 2010 23:12:29 +0000 Subject: [PATCH] rename llvm_install_error_handler -> install_fatal_error_handler and friends. llvm-svn: 100717 --- llvm/include/llvm/Support/ErrorHandling.h | 18 +++++++------- llvm/lib/Support/ErrorHandling.cpp | 29 ++++++++++------------- 2 files changed, 22 insertions(+), 25 deletions(-) diff --git a/llvm/include/llvm/Support/ErrorHandling.h b/llvm/include/llvm/Support/ErrorHandling.h index f7767452294d..ffcb482f75c5 100644 --- a/llvm/include/llvm/Support/ErrorHandling.h +++ b/llvm/include/llvm/Support/ErrorHandling.h @@ -1,4 +1,4 @@ -//===- llvm/Support/ErrorHandling.h - Callbacks for errors ------*- C++ -*-===// +//===- llvm/Support/ErrorHandling.h - Fatal error handling ------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -7,8 +7,8 @@ // //===----------------------------------------------------------------------===// // -// This file defines an API used to indicate error conditions. -// Callbacks can be registered for these errors through this API. +// This file defines an API used to indicate fatal error conditions. Non-fatal +// errors (most of them) should be handled through LLVMContext. // //===----------------------------------------------------------------------===// @@ -22,10 +22,10 @@ namespace llvm { class Twine; /// An error handler callback. - typedef void (*llvm_error_handler_t)(void *user_data, - const std::string& reason); + typedef void (*fatal_error_handler_t)(void *user_data, + const std::string& reason); - /// llvm_install_error_handler - Installs a new error handler to be used + /// install_fatal_error_handler - Installs a new error handler to be used /// whenever a serious (non-recoverable) error is encountered by LLVM. /// /// If you are using llvm_start_multithreaded, you should register the handler @@ -44,13 +44,13 @@ namespace llvm { /// /// \param user_data - An argument which will be passed to the install error /// handler. - void llvm_install_error_handler(llvm_error_handler_t handler, - void *user_data = 0); + void install_fatal_error_handler(fatal_error_handler_t handler, + void *user_data = 0); /// Restores default error handling behaviour. /// This must not be called between llvm_start_multithreaded() and /// llvm_stop_multithreaded(). - void llvm_remove_error_handler(); + void remove_fatal_error_handler(); /// Reports a serious error, calling any installed error handler. These /// functions are intended to be used for error conditions which are outside diff --git a/llvm/lib/Support/ErrorHandling.cpp b/llvm/lib/Support/ErrorHandling.cpp index 32a5d4bcb63d..56a171cb7d37 100644 --- a/llvm/lib/Support/ErrorHandling.cpp +++ b/llvm/lib/Support/ErrorHandling.cpp @@ -1,4 +1,4 @@ -//===- lib/Support/ErrorHandling.cpp - Callbacks for errors -----*- C++ -*-===// +//===- lib/Support/ErrorHandling.cpp - Callbacks for errors ---------------===// // // The LLVM Compiler Infrastructure // @@ -7,9 +7,9 @@ // //===----------------------------------------------------------------------===// // -// This file defines an API for error handling, it supersedes cerr+abort(), and -// cerr+exit() style error handling. -// Callbacks can be registered for these errors through this API. +// This file defines an API used to indicate fatal error conditions. Non-fatal +// errors (most of them) should be handled through LLVMContext. +// //===----------------------------------------------------------------------===// #include "llvm/ADT/Twine.h" @@ -19,16 +19,14 @@ #include "llvm/System/Threading.h" #include #include - using namespace llvm; using namespace std; -static llvm_error_handler_t ErrorHandler = 0; +static fatal_error_handler_t ErrorHandler = 0; static void *ErrorHandlerUserData = 0; -namespace llvm { -void llvm_install_error_handler(llvm_error_handler_t handler, - void *user_data) { +void llvm::install_fatal_error_handler(fatal_error_handler_t handler, + void *user_data) { assert(!llvm_is_multithreaded() && "Cannot register error handlers after starting multithreaded mode!\n"); assert(!ErrorHandler && "Error handler already registered!\n"); @@ -36,19 +34,19 @@ void llvm_install_error_handler(llvm_error_handler_t handler, ErrorHandlerUserData = user_data; } -void llvm_remove_error_handler() { +void llvm::remove_fatal_error_handler() { ErrorHandler = 0; } -void report_fatal_error(const char *reason) { +void llvm::report_fatal_error(const char *reason) { report_fatal_error(Twine(reason)); } -void report_fatal_error(const std::string &reason) { +void llvm::report_fatal_error(const std::string &reason) { report_fatal_error(Twine(reason)); } -void report_fatal_error(const Twine &reason) { +void llvm::report_fatal_error(const Twine &reason) { if (!ErrorHandler) { errs() << "LLVM ERROR: " << reason << "\n"; } else { @@ -57,8 +55,8 @@ void report_fatal_error(const Twine &reason) { exit(1); } -void llvm_unreachable_internal(const char *msg, const char *file, - unsigned line) { +void llvm::llvm_unreachable_internal(const char *msg, const char *file, + unsigned line) { // This code intentionally doesn't call the ErrorHandler callback, because // llvm_unreachable is intended to be used to indicate "impossible" // situations, and not legitimate runtime errors. @@ -70,4 +68,3 @@ void llvm_unreachable_internal(const char *msg, const char *file, dbgs() << "!\n"; abort(); } -}