LLVM  9.0.0svn
ErrorHandling.cpp
Go to the documentation of this file.
1 //===- lib/Support/ErrorHandling.cpp - Callbacks for errors ---------------===//
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 // This file defines an API used to indicate fatal error conditions. Non-fatal
10 // errors (most of them) should be handled through LLVMContext.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm-c/ErrorHandling.h"
16 #include "llvm/ADT/SmallVector.h"
17 #include "llvm/ADT/Twine.h"
18 #include "llvm/Config/config.h"
19 #include "llvm/Support/Debug.h"
20 #include "llvm/Support/Errc.h"
21 #include "llvm/Support/Error.h"
22 #include "llvm/Support/Signals.h"
23 #include "llvm/Support/Threading.h"
26 #include <cassert>
27 #include <cstdlib>
28 #include <mutex>
29 #include <new>
30 
31 #if defined(HAVE_UNISTD_H)
32 # include <unistd.h>
33 #endif
34 #if defined(_MSC_VER)
35 # include <io.h>
36 # include <fcntl.h>
37 #endif
38 
39 using namespace llvm;
40 
42 static void *ErrorHandlerUserData = nullptr;
43 
45 static void *BadAllocErrorHandlerUserData = nullptr;
46 
47 #if LLVM_ENABLE_THREADS == 1
48 // Mutexes to synchronize installing error handlers and calling error handlers.
49 // Do not use ManagedStatic, or that may allocate memory while attempting to
50 // report an OOM.
51 //
52 // This usage of std::mutex has to be conditionalized behind ifdefs because
53 // of this script:
54 // compiler-rt/lib/sanitizer_common/symbolizer/scripts/build_symbolizer.sh
55 // That script attempts to statically link the LLVM symbolizer library with the
56 // STL and hide all of its symbols with 'opt -internalize'. To reduce size, it
57 // cuts out the threading portions of the hermetic copy of libc++ that it
58 // builds. We can remove these ifdefs if that script goes away.
59 static std::mutex ErrorHandlerMutex;
60 static std::mutex BadAllocErrorHandlerMutex;
61 #endif
62 
64  void *user_data) {
65 #if LLVM_ENABLE_THREADS == 1
66  std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
67 #endif
68  assert(!ErrorHandler && "Error handler already registered!\n");
69  ErrorHandler = handler;
70  ErrorHandlerUserData = user_data;
71 }
72 
74 #if LLVM_ENABLE_THREADS == 1
75  std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
76 #endif
77  ErrorHandler = nullptr;
78  ErrorHandlerUserData = nullptr;
79 }
80 
81 void llvm::report_fatal_error(const char *Reason, bool GenCrashDiag) {
82  report_fatal_error(Twine(Reason), GenCrashDiag);
83 }
84 
85 void llvm::report_fatal_error(const std::string &Reason, bool GenCrashDiag) {
86  report_fatal_error(Twine(Reason), GenCrashDiag);
87 }
88 
89 void llvm::report_fatal_error(StringRef Reason, bool GenCrashDiag) {
90  report_fatal_error(Twine(Reason), GenCrashDiag);
91 }
92 
93 void llvm::report_fatal_error(const Twine &Reason, bool GenCrashDiag) {
94  llvm::fatal_error_handler_t handler = nullptr;
95  void* handlerData = nullptr;
96  {
97  // Only acquire the mutex while reading the handler, so as not to invoke a
98  // user-supplied callback under a lock.
99 #if LLVM_ENABLE_THREADS == 1
100  std::lock_guard<std::mutex> Lock(ErrorHandlerMutex);
101 #endif
102  handler = ErrorHandler;
103  handlerData = ErrorHandlerUserData;
104  }
105 
106  if (handler) {
107  handler(handlerData, Reason.str(), GenCrashDiag);
108  } else {
109  // Blast the result out to stderr. We don't try hard to make sure this
110  // succeeds (e.g. handling EINTR) and we can't use errs() here because
111  // raw ostreams can call report_fatal_error.
112  SmallVector<char, 64> Buffer;
113  raw_svector_ostream OS(Buffer);
114  OS << "LLVM ERROR: " << Reason << "\n";
115  StringRef MessageStr = OS.str();
116  ssize_t written = ::write(2, MessageStr.data(), MessageStr.size());
117  (void)written; // If something went wrong, we deliberately just give up.
118  }
119 
120  // If we reached here, we are failing ungracefully. Run the interrupt handlers
121  // to make sure any special cleanups get done, in particular that we remove
122  // files registered with RemoveFileOnSignal.
124 
125  exit(1);
126 }
127 
129  void *user_data) {
130 #if LLVM_ENABLE_THREADS == 1
131  std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
132 #endif
133  assert(!ErrorHandler && "Bad alloc error handler already registered!\n");
134  BadAllocErrorHandler = handler;
135  BadAllocErrorHandlerUserData = user_data;
136 }
137 
139 #if LLVM_ENABLE_THREADS == 1
140  std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
141 #endif
142  BadAllocErrorHandler = nullptr;
144 }
145 
146 void llvm::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {
147  fatal_error_handler_t Handler = nullptr;
148  void *HandlerData = nullptr;
149  {
150  // Only acquire the mutex while reading the handler, so as not to invoke a
151  // user-supplied callback under a lock.
152 #if LLVM_ENABLE_THREADS == 1
153  std::lock_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
154 #endif
155  Handler = BadAllocErrorHandler;
156  HandlerData = BadAllocErrorHandlerUserData;
157  }
158 
159  if (Handler) {
160  Handler(HandlerData, Reason, GenCrashDiag);
161  llvm_unreachable("bad alloc handler should not return");
162  }
163 
164 #ifdef LLVM_ENABLE_EXCEPTIONS
165  // If exceptions are enabled, make OOM in malloc look like OOM in new.
166  throw std::bad_alloc();
167 #else
168  // Don't call the normal error handler. It may allocate memory. Directly write
169  // an OOM to stderr and abort.
170  char OOMMessage[] = "LLVM ERROR: out of memory\n";
171  ssize_t written = ::write(2, OOMMessage, strlen(OOMMessage));
172  (void)written;
173  abort();
174 #endif
175 }
176 
177 #ifdef LLVM_ENABLE_EXCEPTIONS
178 // Do not set custom new handler if exceptions are enabled. In this case OOM
179 // errors are handled by throwing 'std::bad_alloc'.
181 }
182 #else
183 // Causes crash on allocation failure. It is called prior to the handler set by
184 // 'install_bad_alloc_error_handler'.
186  llvm::report_bad_alloc_error("Allocation failed");
187 }
188 
189 // Installs new handler that causes crash on allocation failure. It does not
190 // need to be called explicitly, if this file is linked to application, because
191 // in this case it is called during construction of 'new_handler_installer'.
193  static bool out_of_memory_new_handler_installed = false;
194  if (!out_of_memory_new_handler_installed) {
195  std::set_new_handler(out_of_memory_new_handler);
196  out_of_memory_new_handler_installed = true;
197  }
198 }
199 
200 // Static object that causes installation of 'out_of_memory_new_handler' before
201 // execution of 'main'.
202 static class NewHandlerInstaller {
203 public:
206  }
208 #endif
209 
210 void llvm::llvm_unreachable_internal(const char *msg, const char *file,
211  unsigned line) {
212  // This code intentionally doesn't call the ErrorHandler callback, because
213  // llvm_unreachable is intended to be used to indicate "impossible"
214  // situations, and not legitimate runtime errors.
215  if (msg)
216  dbgs() << msg << "\n";
217  dbgs() << "UNREACHABLE executed";
218  if (file)
219  dbgs() << " at " << file << ":" << line;
220  dbgs() << "!\n";
221  abort();
222 #ifdef LLVM_BUILTIN_UNREACHABLE
223  // Windows systems and possibly others don't declare abort() to be noreturn,
224  // so use the unreachable builtin to avoid a Clang self-host warning.
225  LLVM_BUILTIN_UNREACHABLE;
226 #endif
227 }
228 
229 static void bindingsErrorHandler(void *user_data, const std::string& reason,
230  bool gen_crash_diag) {
231  LLVMFatalErrorHandler handler =
232  LLVM_EXTENSION reinterpret_cast<LLVMFatalErrorHandler>(user_data);
233  handler(reason.c_str());
234 }
235 
238  LLVM_EXTENSION reinterpret_cast<void *>(Handler));
239 }
240 
243 }
244 
245 #ifdef _WIN32
246 
247 #include <winerror.h>
248 
249 // I'd rather not double the line count of the following.
250 #define MAP_ERR_TO_COND(x, y) \
251  case x: \
252  return make_error_code(errc::y)
253 
254 std::error_code llvm::mapWindowsError(unsigned EV) {
255  switch (EV) {
256  MAP_ERR_TO_COND(ERROR_ACCESS_DENIED, permission_denied);
257  MAP_ERR_TO_COND(ERROR_ALREADY_EXISTS, file_exists);
258  MAP_ERR_TO_COND(ERROR_BAD_UNIT, no_such_device);
259  MAP_ERR_TO_COND(ERROR_BUFFER_OVERFLOW, filename_too_long);
260  MAP_ERR_TO_COND(ERROR_BUSY, device_or_resource_busy);
261  MAP_ERR_TO_COND(ERROR_BUSY_DRIVE, device_or_resource_busy);
262  MAP_ERR_TO_COND(ERROR_CANNOT_MAKE, permission_denied);
263  MAP_ERR_TO_COND(ERROR_CANTOPEN, io_error);
264  MAP_ERR_TO_COND(ERROR_CANTREAD, io_error);
265  MAP_ERR_TO_COND(ERROR_CANTWRITE, io_error);
266  MAP_ERR_TO_COND(ERROR_CURRENT_DIRECTORY, permission_denied);
267  MAP_ERR_TO_COND(ERROR_DEV_NOT_EXIST, no_such_device);
268  MAP_ERR_TO_COND(ERROR_DEVICE_IN_USE, device_or_resource_busy);
269  MAP_ERR_TO_COND(ERROR_DIR_NOT_EMPTY, directory_not_empty);
270  MAP_ERR_TO_COND(ERROR_DIRECTORY, invalid_argument);
271  MAP_ERR_TO_COND(ERROR_DISK_FULL, no_space_on_device);
272  MAP_ERR_TO_COND(ERROR_FILE_EXISTS, file_exists);
273  MAP_ERR_TO_COND(ERROR_FILE_NOT_FOUND, no_such_file_or_directory);
274  MAP_ERR_TO_COND(ERROR_HANDLE_DISK_FULL, no_space_on_device);
275  MAP_ERR_TO_COND(ERROR_INVALID_ACCESS, permission_denied);
276  MAP_ERR_TO_COND(ERROR_INVALID_DRIVE, no_such_device);
277  MAP_ERR_TO_COND(ERROR_INVALID_FUNCTION, function_not_supported);
278  MAP_ERR_TO_COND(ERROR_INVALID_HANDLE, invalid_argument);
279  MAP_ERR_TO_COND(ERROR_INVALID_NAME, invalid_argument);
280  MAP_ERR_TO_COND(ERROR_LOCK_VIOLATION, no_lock_available);
281  MAP_ERR_TO_COND(ERROR_LOCKED, no_lock_available);
282  MAP_ERR_TO_COND(ERROR_NEGATIVE_SEEK, invalid_argument);
283  MAP_ERR_TO_COND(ERROR_NOACCESS, permission_denied);
284  MAP_ERR_TO_COND(ERROR_NOT_ENOUGH_MEMORY, not_enough_memory);
285  MAP_ERR_TO_COND(ERROR_NOT_READY, resource_unavailable_try_again);
286  MAP_ERR_TO_COND(ERROR_OPEN_FAILED, io_error);
287  MAP_ERR_TO_COND(ERROR_OPEN_FILES, device_or_resource_busy);
288  MAP_ERR_TO_COND(ERROR_OUTOFMEMORY, not_enough_memory);
289  MAP_ERR_TO_COND(ERROR_PATH_NOT_FOUND, no_such_file_or_directory);
290  MAP_ERR_TO_COND(ERROR_BAD_NETPATH, no_such_file_or_directory);
291  MAP_ERR_TO_COND(ERROR_READ_FAULT, io_error);
292  MAP_ERR_TO_COND(ERROR_RETRY, resource_unavailable_try_again);
293  MAP_ERR_TO_COND(ERROR_SEEK, io_error);
294  MAP_ERR_TO_COND(ERROR_SHARING_VIOLATION, permission_denied);
295  MAP_ERR_TO_COND(ERROR_TOO_MANY_OPEN_FILES, too_many_files_open);
296  MAP_ERR_TO_COND(ERROR_WRITE_FAULT, io_error);
297  MAP_ERR_TO_COND(ERROR_WRITE_PROTECT, permission_denied);
298  MAP_ERR_TO_COND(WSAEACCES, permission_denied);
299  MAP_ERR_TO_COND(WSAEBADF, bad_file_descriptor);
300  MAP_ERR_TO_COND(WSAEFAULT, bad_address);
301  MAP_ERR_TO_COND(WSAEINTR, interrupted);
302  MAP_ERR_TO_COND(WSAEINVAL, invalid_argument);
303  MAP_ERR_TO_COND(WSAEMFILE, too_many_files_open);
304  MAP_ERR_TO_COND(WSAENAMETOOLONG, filename_too_long);
305  default:
306  return std::error_code(EV, std::system_category());
307  }
308 }
309 
310 #endif
void(* LLVMFatalErrorHandler)(const char *Reason)
Definition: ErrorHandling.h:21
*ViewGraph Emit a dot run run gv on the postscript file
Definition: GraphWriter.h:362
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:139
This class represents lattice values for constants.
Definition: AllocatorList.h:23
static void bindingsErrorHandler(void *user_data, const std::string &reason, bool gen_crash_diag)
static sys::Mutex Lock
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:509
void install_bad_alloc_error_handler(fatal_error_handler_t handler, void *user_data=nullptr)
Installs a new bad alloc error handler that should be used whenever a bad alloc error, e.g.
static class NewHandlerInstaller new_handler_installer
static void * ErrorHandlerUserData
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
static fatal_error_handler_t ErrorHandler
void remove_fatal_error_handler()
Restores default error handling behaviour.
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
#define LLVM_EXTENSION
LLVM_EXTENSION - Support compilers where we have a keyword to suppress pedantic diagnostics.
Definition: Compiler.h:262
void(* fatal_error_handler_t)(void *user_data, const std::string &reason, bool gen_crash_diag)
An error handler callback.
Definition: ErrorHandling.h:25
void remove_bad_alloc_error_handler()
Restores default bad alloc error handling behavior.
static void * BadAllocErrorHandlerUserData
void RunInterruptHandlers()
This function runs all the registered interrupt handlers, including the removal of files registered b...
std::error_code mapWindowsError(unsigned EV)
static std::mutex BadAllocErrorHandlerMutex
static void write(bool isBE, void *P, T V)
static void out_of_memory_new_handler()
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void report_bad_alloc_error(const char *Reason, bool GenCrashDiag=true)
Reports a bad alloc error, calling any user defined bad alloc error handler.
void LLVMInstallFatalErrorHandler(LLVMFatalErrorHandler Handler)
Install a fatal error handler.
static fatal_error_handler_t BadAllocErrorHandler
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:841
StringRef str()
Return a StringRef for the vector contents.
Definition: raw_ostream.h:534
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
LLVM_ATTRIBUTE_NORETURN void llvm_unreachable_internal(const char *msg=nullptr, const char *file=nullptr, unsigned line=0)
This function calls abort(), and prints the optional message to stderr.
void LLVMResetFatalErrorHandler()
Reset the fatal error handler.
static std::mutex ErrorHandlerMutex
std::string str() const
Return the twine contents as a std::string.
Definition: Twine.cpp:17
LLVM_NODISCARD const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:122
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
void install_out_of_memory_new_handler()
void install_fatal_error_handler(fatal_error_handler_t handler, void *user_data=nullptr)
install_fatal_error_handler - Installs a new error handler to be used whenever a serious (non-recover...