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(std::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 dbgs() << "\n"; 109 }else 110 dbgs() << "Error value was Success. (Note: Success values must still be " 111 "checked prior to being destroyed).\n"; 112 abort(); 113 } 114 #endif 115 116 StringError::StringError(std::error_code EC, const Twine &S) 117 : Msg(S.str()), EC(EC) {} 118 119 StringError::StringError(const Twine &S, std::error_code EC) 120 : Msg(S.str()), EC(EC), PrintMsgOnly(true) {} 121 122 void StringError::log(raw_ostream &OS) const { 123 if (PrintMsgOnly) { 124 OS << Msg; 125 } else { 126 OS << EC.message(); 127 if (!Msg.empty()) 128 OS << (" " + Msg); 129 } 130 } 131 132 std::error_code StringError::convertToErrorCode() const { 133 return EC; 134 } 135 136 Error createStringError(std::error_code EC, char const *Msg) { 137 return make_error<StringError>(Msg, EC); 138 } 139 140 void report_fatal_error(Error Err, bool GenCrashDiag) { 141 assert(Err && "report_fatal_error called with success value"); 142 std::string ErrMsg; 143 { 144 raw_string_ostream ErrStream(ErrMsg); 145 logAllUnhandledErrors(std::move(Err), ErrStream); 146 } 147 report_fatal_error(ErrMsg); 148 } 149 150 } // end namespace llvm 151 152 LLVMErrorTypeId LLVMGetErrorTypeId(LLVMErrorRef Err) { 153 return reinterpret_cast<ErrorInfoBase *>(Err)->dynamicClassID(); 154 } 155 156 void LLVMConsumeError(LLVMErrorRef Err) { consumeError(unwrap(Err)); } 157 158 char *LLVMGetErrorMessage(LLVMErrorRef Err) { 159 std::string Tmp = toString(unwrap(Err)); 160 char *ErrMsg = new char[Tmp.size() + 1]; 161 memcpy(ErrMsg, Tmp.data(), Tmp.size()); 162 ErrMsg[Tmp.size()] = '\0'; 163 return ErrMsg; 164 } 165 166 void LLVMDisposeErrorMessage(char *ErrMsg) { delete[] ErrMsg; } 167 168 LLVMErrorTypeId LLVMGetStringErrorTypeId() { 169 return reinterpret_cast<void *>(&StringError::ID); 170 } 171