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 return std::error_code(static_cast<int>(ErrorErrorCode::FileError), 84 *ErrorErrorCat); 85 } 86 87 Error errorCodeToError(std::error_code EC) { 88 if (!EC) 89 return Error::success(); 90 return Error(llvm::make_unique<ECError>(ECError(EC))); 91 } 92 93 std::error_code errorToErrorCode(Error Err) { 94 std::error_code EC; 95 handleAllErrors(std::move(Err), [&](const ErrorInfoBase &EI) { 96 EC = EI.convertToErrorCode(); 97 }); 98 if (EC == inconvertibleErrorCode()) 99 report_fatal_error(EC.message()); 100 return EC; 101 } 102 103 #if LLVM_ENABLE_ABI_BREAKING_CHECKS 104 void Error::fatalUncheckedError() const { 105 dbgs() << "Program aborted due to an unhandled Error:\n"; 106 if (getPtr()) 107 getPtr()->log(dbgs()); 108 else 109 dbgs() << "Error value was Success. (Note: Success values must still be " 110 "checked prior to being destroyed).\n"; 111 abort(); 112 } 113 #endif 114 115 StringError::StringError(std::error_code EC, const Twine &S) 116 : Msg(S.str()), EC(EC) {} 117 118 StringError::StringError(const Twine &S, std::error_code EC) 119 : Msg(S.str()), EC(EC), PrintMsgOnly(true) {} 120 121 void StringError::log(raw_ostream &OS) const { 122 if (PrintMsgOnly) { 123 OS << Msg; 124 } else { 125 OS << EC.message(); 126 if (!Msg.empty()) 127 OS << (" " + Msg); 128 } 129 } 130 131 std::error_code StringError::convertToErrorCode() const { 132 return EC; 133 } 134 135 Error createStringError(std::error_code EC, char const *Msg) { 136 return make_error<StringError>(Msg, EC); 137 } 138 139 void report_fatal_error(Error Err, bool GenCrashDiag) { 140 assert(Err && "report_fatal_error called with success value"); 141 std::string ErrMsg; 142 { 143 raw_string_ostream ErrStream(ErrMsg); 144 logAllUnhandledErrors(std::move(Err), ErrStream); 145 } 146 report_fatal_error(ErrMsg); 147 } 148 149 } // end namespace llvm 150 151 LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err) { 152 return reinterpret_cast<ErrorInfoBase *>(Err)->dynamicClassID(); 153 } 154 155 void LLVMConsumeError(LLVMErrorRef Err) { consumeError(unwrap(Err)); } 156 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'; 162 return ErrMsg; 163 } 164 165 void LLVMDisposeErrorMessage(char *ErrMsg) { delete[] ErrMsg; } 166 167 LLVMErrorTypeId LLVMGetStringErrorTypeId() { 168 return reinterpret_cast<void *>(&StringError::ID); 169 } 170 171 #ifndef _MSC_VER 172 namespace llvm { 173 174 // One of these two variables will be referenced by a symbol defined in 175 // llvm-config.h. We provide a link-time (or load time for DSO) failure when 176 // there is a mismatch in the build configuration of the API client and LLVM. 177 #if LLVM_ENABLE_ABI_BREAKING_CHECKS 178 int EnableABIBreakingChecks; 179 #else 180 int DisableABIBreakingChecks; 181 #endif 182 183 } // end namespace llvm 184 #endif 185