LCOV - code coverage report
Current view: top level - lib/Support - ErrorHandling.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 27 67 40.3 %
Date: 2018-09-23 13:06:45 Functions: 6 15 40.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.13