1 //===----- lib/Support/Error.cpp - Error and associated utilities ---------===// 2 // 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 6 // 7 //===----------------------------------------------------------------------===// 8 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> 14 15 using namespace llvm; 16 17 namespace { 18 19 enum class ErrorErrorCode : int { 20 MultipleErrors = 1, 21 FileError, 22 InconvertibleError 23 }; 24 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 { 29 public: 30 const char *name() const noexcept override { return "Error"; } 31 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 " 39 "bug."; 40 case ErrorErrorCode::FileError: 41 return "A file error occurred."; 42 } 43 llvm_unreachable("Unhandled error code"); 44 } 45 }; 46 47 } 48 49 static ManagedStatic<ErrorErrorCategory> ErrorErrorCat; 50 51 namespace llvm { 52 53 void ErrorInfoBase::anchor() {} 54 char ErrorInfoBase::ID = 0; 55 char ErrorList::ID = 0; 56 void ECError::anchor() {} 57 char ECError::ID = 0; 58 char StringError::ID = 0; 59 char FileError::ID = 0; 60 61 void logAllUnhandledErrors(Error E, raw_ostream &OS, Twine ErrorBanner) { 62 if (!E) 63 return; 64 OS << ErrorBanner; 65 handleAllErrors(std::move(E), [&](const ErrorInfoBase &EI) { 66 EI.log(OS); 67 OS << "\n"; 68 }); 69 } 70 71 72 std::error_code ErrorList::convertToErrorCode() const { 73 return std::error_code(static_cast<int>(ErrorErrorCode::MultipleErrors), 74 *ErrorErrorCat); 75 } 76 77 std::error_code inconvertibleErrorCode() { 78 return std::error_code(static_cast<int>(ErrorErrorCode::InconvertibleError), 79 *ErrorErrorCat); 80 } 81 82 std::error_code FileError::convertToErrorCode() const { 83 std::error_code NestedEC = Err->convertToErrorCode(); 84 if (NestedEC == inconvertibleErrorCode()) 85 return std::error_code(static_cast<int>(ErrorErrorCode::FileError), 86 *ErrorErrorCat); 87 return NestedEC; 88 } 89 90 Error errorCodeToError(std::error_code EC) { 91 if (!EC) 92 return Error::success(); 93 return Error(std::make_unique<ECError>(ECError(EC))); 94 } 95 96 std::error_code errorToErrorCode(Error Err) { 97 std::error_code EC; 98 handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { 99 EC = EI.convertToErrorCode(); 100 }); 101 if (EC == inconvertibleErrorCode()) 102 report_fatal_error(Twine(EC.message())); 103 return EC; 104 } 105 106 #if LLVM_ENABLE_ABI_BREAKING_CHECKS 107 void Error::fatalUncheckedError() const { 108 dbgs() << "Program aborted due to an unhandled Error:\n"; 109 if (getPtr()) { 110 getPtr()->log(dbgs()); 111 dbgs() << "\n"; 112 }else 113 dbgs() << "Error value was Success. (Note: Success values must still be " 114 "checked prior to being destroyed).\n"; 115 abort(); 116 } 117 #endif 118 119 StringError::StringError(std::error_code EC, const Twine &S) 120 : Msg(S.str()), EC(EC) {} 121 122 StringError::StringError(const Twine &S, std::error_code EC) 123 : Msg(S.str()), EC(EC), PrintMsgOnly(true) {} 124 125 void StringError::log(raw_ostream &OS) const { 126 if (PrintMsgOnly) { 127 OS << Msg; 128 } else { 129 OS << EC.message(); 130 if (!Msg.empty()) 131 OS << (" " + Msg); 132 } 133 } 134 135 std::error_code StringError::convertToErrorCode() const { 136 return EC; 137 } 138 139 Error createStringError(std::error_code EC, char const *Msg) { 140 return make_error<StringError>(Msg, EC); 141 } 142 143 void report_fatal_error(Error Err, bool GenCrashDiag) { 144 assert(Err && "report_fatal_error called with success value"); 145 std::string ErrMsg; 146 { 147 raw_string_ostream ErrStream(ErrMsg); 148 logAllUnhandledErrors(std::move(Err), ErrStream); 149 } 150 report_fatal_error(Twine(ErrMsg)); 151 } 152 153 } // end namespace llvm 154 155 LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err) { 156 return reinterpret_cast<ErrorInfoBase *>(Err)->dynamicClassID(); 157 } 158 159 void LLVMConsumeError(LLVMErrorRef Err) { consumeError(unwrap(Err)); } 160 161 char *LLVMGetErrorMessage(LLVMErrorRef Err) { 162 std::string Tmp = toString(unwrap(Err)); 163 char *ErrMsg = new char[Tmp.size() + 1]; 164 memcpy(ErrMsg, Tmp.data(), Tmp.size()); 165 ErrMsg[Tmp.size()] = '\0'; 166 return ErrMsg; 167 } 168 169 void LLVMDisposeErrorMessage(char *ErrMsg) { delete[] ErrMsg; } 170 171 LLVMErrorTypeId LLVMGetStringErrorTypeId() { 172 return reinterpret_cast<void *>(&StringError::ID); 173 } 174 175 LLVMErrorRef LLVMCreateStringError(const char *ErrMsg) { 176 return wrap(make_error<StringError>(ErrMsg, inconvertibleErrorCode())); 177 } 178