mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-18 18:42:46 +02:00
eb66b33867
I did this a long time ago with a janky python script, but now clang-format has built-in support for this. I fed clang-format every line with a #include and let it re-sort things according to the precise LLVM rules for include ordering baked into clang-format these days. I've reverted a number of files where the results of sorting includes isn't healthy. Either places where we have legacy code relying on particular include ordering (where possible, I'll fix these separately) or where we have particular formatting around #include lines that I didn't want to disturb in this patch. This patch is *entirely* mechanical. If you get merge conflicts or anything, just ignore the changes in this patch and run clang-format over your #include lines in the files. Sorry for any noise here, but it is important to keep these things stable. I was seeing an increasing number of patches with irrelevant re-ordering of #include lines because clang-format was used. This patch at least isolates that churn, makes it easy to skip when resolving conflicts, and gets us to a clean baseline (again). llvm-svn: 304787
129 lines
3.5 KiB
C++
129 lines
3.5 KiB
C++
//===----- lib/Support/Error.cpp - Error and associated utilities ---------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Support/Error.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include "llvm/Support/ManagedStatic.h"
|
|
#include <system_error>
|
|
|
|
using namespace llvm;
|
|
|
|
namespace {
|
|
|
|
enum class ErrorErrorCode : int {
|
|
MultipleErrors = 1,
|
|
InconvertibleError
|
|
};
|
|
|
|
// FIXME: This class is only here to support the transition to llvm::Error. It
|
|
// will be removed once this transition is complete. Clients should prefer to
|
|
// deal with the Error value directly, rather than converting to error_code.
|
|
class ErrorErrorCategory : public std::error_category {
|
|
public:
|
|
const char *name() const noexcept override { return "Error"; }
|
|
|
|
std::string message(int condition) const override {
|
|
switch (static_cast<ErrorErrorCode>(condition)) {
|
|
case ErrorErrorCode::MultipleErrors:
|
|
return "Multiple errors";
|
|
case ErrorErrorCode::InconvertibleError:
|
|
return "Inconvertible error value. An error has occurred that could "
|
|
"not be converted to a known std::error_code. Please file a "
|
|
"bug.";
|
|
}
|
|
llvm_unreachable("Unhandled error code");
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
static ManagedStatic<ErrorErrorCategory> ErrorErrorCat;
|
|
|
|
namespace llvm {
|
|
|
|
void ErrorInfoBase::anchor() {}
|
|
char ErrorInfoBase::ID = 0;
|
|
char ErrorList::ID = 0;
|
|
char ECError::ID = 0;
|
|
char StringError::ID = 0;
|
|
|
|
void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner) {
|
|
if (!E)
|
|
return;
|
|
OS << ErrorBanner;
|
|
handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) {
|
|
EI.log(OS);
|
|
OS << "\n";
|
|
});
|
|
}
|
|
|
|
|
|
std::error_code ErrorList::convertToErrorCode() const {
|
|
return std::error_code(static_cast<int>(ErrorErrorCode::MultipleErrors),
|
|
*ErrorErrorCat);
|
|
}
|
|
|
|
std::error_code inconvertibleErrorCode() {
|
|
return std::error_code(static_cast<int>(ErrorErrorCode::InconvertibleError),
|
|
*ErrorErrorCat);
|
|
}
|
|
|
|
Error errorCodeToError(std::error_code EC) {
|
|
if (!EC)
|
|
return Error::success();
|
|
return Error(llvm::make_unique<ECError>(ECError(EC)));
|
|
}
|
|
|
|
std::error_code errorToErrorCode(Error Err) {
|
|
std::error_code EC;
|
|
handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) {
|
|
EC = EI.convertToErrorCode();
|
|
});
|
|
if (EC == inconvertibleErrorCode())
|
|
report_fatal_error(EC.message());
|
|
return EC;
|
|
}
|
|
|
|
StringError::StringError(const Twine &S, std::error_code EC)
|
|
: Msg(S.str()), EC(EC) {}
|
|
|
|
void StringError::log(raw_ostream &OS) const { OS << Msg; }
|
|
|
|
std::error_code StringError::convertToErrorCode() const {
|
|
return EC;
|
|
}
|
|
|
|
void report_fatal_error(Error Err, bool GenCrashDiag) {
|
|
assert(Err && "report_fatal_error called with success value");
|
|
std::string ErrMsg;
|
|
{
|
|
raw_string_ostream ErrStream(ErrMsg);
|
|
logAllUnhandledErrors(std::move(Err), ErrStream, "");
|
|
}
|
|
report_fatal_error(ErrMsg);
|
|
}
|
|
|
|
}
|
|
|
|
#ifndef _MSC_VER
|
|
namespace llvm {
|
|
|
|
// One of these two variables will be referenced by a symbol defined in
|
|
// llvm-config.h. We provide a link-time (or load time for DSO) failure when
|
|
// there is a mismatch in the build configuration of the API client and LLVM.
|
|
#if LLVM_ENABLE_ABI_BREAKING_CHECKS
|
|
int EnableABIBreakingChecks;
|
|
#else
|
|
int DisableABIBreakingChecks;
|
|
#endif
|
|
|
|
} // end namespace llvm
|
|
#endif
|