1 //===----- lib/Support/Error.cpp - Error and associated utilities ---------===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 #include "llvm/Support/Error.h"
10 #include "llvm/ADT/Twine.h"
11 #include "llvm/Support/ErrorHandling.h"
12 #include "llvm/Support/ManagedStatic.h"
13 #include <system_error>
19 enum class ErrorErrorCode
: int {
25 // FIXME: This class is only here to support the transition to llvm::Error. It
26 // will be removed once this transition is complete. Clients should prefer to
27 // deal with the Error value directly, rather than converting to error_code.
28 class ErrorErrorCategory
: public std::error_category
{
30 const char *name() const noexcept override
{ return "Error"; }
32 std::string
message(int condition
) const override
{
33 switch (static_cast<ErrorErrorCode
>(condition
)) {
34 case ErrorErrorCode::MultipleErrors
:
35 return "Multiple errors";
36 case ErrorErrorCode::InconvertibleError
:
37 return "Inconvertible error value. An error has occurred that could "
38 "not be converted to a known std::error_code. Please file a "
40 case ErrorErrorCode::FileError
:
41 return "A file error occurred.";
43 llvm_unreachable("Unhandled error code");
49 static ManagedStatic
<ErrorErrorCategory
> ErrorErrorCat
;
53 void ErrorInfoBase::anchor() {}
54 char ErrorInfoBase::ID
= 0;
55 char ErrorList::ID
= 0;
56 void ECError::anchor() {}
58 char StringError::ID
= 0;
59 char FileError::ID
= 0;
61 void logAllUnhandledErrors(Error E
, raw_ostream
&OS
, Twine ErrorBanner
) {
65 handleAllErrors(std::move(E
), [&](const ErrorInfoBase
&EI
) {
72 std::error_code
ErrorList::convertToErrorCode() const {
73 return std::error_code(static_cast<int>(ErrorErrorCode::MultipleErrors
),
77 std::error_code
inconvertibleErrorCode() {
78 return std::error_code(static_cast<int>(ErrorErrorCode::InconvertibleError
),
82 std::error_code
FileError::convertToErrorCode() const {
83 return std::error_code(static_cast<int>(ErrorErrorCode::FileError
),
87 Error
errorCodeToError(std::error_code EC
) {
89 return Error::success();
90 return Error(std::make_unique
<ECError
>(ECError(EC
)));
93 std::error_code
errorToErrorCode(Error Err
) {
95 handleAllErrors(std::move(Err
), [&](const ErrorInfoBase
&EI
) {
96 EC
= EI
.convertToErrorCode();
98 if (EC
== inconvertibleErrorCode())
99 report_fatal_error(EC
.message());
103 #if LLVM_ENABLE_ABI_BREAKING_CHECKS
104 void Error::fatalUncheckedError() const {
105 dbgs() << "Program aborted due to an unhandled Error:\n";
107 getPtr()->log(dbgs());
109 dbgs() << "Error value was Success. (Note: Success values must still be "
110 "checked prior to being destroyed).\n";
115 StringError::StringError(std::error_code EC
, const Twine
&S
)
116 : Msg(S
.str()), EC(EC
) {}
118 StringError::StringError(const Twine
&S
, std::error_code EC
)
119 : Msg(S
.str()), EC(EC
), PrintMsgOnly(true) {}
121 void StringError::log(raw_ostream
&OS
) const {
131 std::error_code
StringError::convertToErrorCode() const {
135 Error
createStringError(std::error_code EC
, char const *Msg
) {
136 return make_error
<StringError
>(Msg
, EC
);
139 void report_fatal_error(Error Err
, bool GenCrashDiag
) {
140 assert(Err
&& "report_fatal_error called with success value");
143 raw_string_ostream
ErrStream(ErrMsg
);
144 logAllUnhandledErrors(std::move(Err
), ErrStream
);
146 report_fatal_error(ErrMsg
);
149 } // end namespace llvm
151 LLVMErrorTypeId
LLVMGetErrorTypeId(LLVMErrorRef Err
) {
152 return reinterpret_cast<ErrorInfoBase
*>(Err
)->dynamicClassID();
155 void LLVMConsumeError(LLVMErrorRef Err
) { consumeError(unwrap(Err
)); }
157 char *LLVMGetErrorMessage(LLVMErrorRef Err
) {
158 std::string Tmp
= toString(unwrap(Err
));
159 char *ErrMsg
= new char[Tmp
.size() + 1];
160 memcpy(ErrMsg
, Tmp
.data(), Tmp
.size());
161 ErrMsg
[Tmp
.size()] = '\0';
165 void LLVMDisposeErrorMessage(char *ErrMsg
) { delete[] ErrMsg
; }
167 LLVMErrorTypeId
LLVMGetStringErrorTypeId() {
168 return reinterpret_cast<void *>(&StringError::ID
);