contrib/llvm-project/lld/Common/ErrorHandler.cpp

   1 //===- ErrorHandler.cpp ---------------------------------------------------===//
   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 "lld/Common/ErrorHandler.h"
  10
  11 #include "lld/Common/Threads.h"
  12
  13 #include "llvm/ADT/Twine.h"
  14 #include "llvm/IR/DiagnosticInfo.h"
  15 #include "llvm/IR/DiagnosticPrinter.h"
  16 #include "llvm/Support/ManagedStatic.h"
  17 #include "llvm/Support/raw_ostream.h"
  18 #include <mutex>
  19 #include <regex>
  20
  21 #if !defined(_MSC_VER) && !defined(__MINGW32__)
  22 #include <unistd.h>
  23 #endif
  24
  25 using namespace llvm;
  26 using namespace lld;
  27
  28 // The functions defined in this file can be called from multiple threads,
  29 // but outs() or errs() are not thread-safe. We protect them using a mutex.
  30 static std::mutex mu;
  31
  32 // Prints "\n" or does nothing, depending on Msg contents of
  33 // the previous call of this function.
  34 static void newline(raw_ostream *errorOS, const Twine &msg) {
  35   // True if the previous error message contained "\n".
  36   // We want to separate multi-line error messages with a newline.
  37   static bool flag;
  38
  39   if (flag)
  40     *errorOS << "\n";
  41   flag = StringRef(msg.str()).contains('\n');
  42 }
  43
  44 ErrorHandler &lld::errorHandler() {
  45   static ErrorHandler handler;
  46   return handler;
  47 }
  48
  49 void lld::exitLld(int val) {
  50   // Delete any temporary file, while keeping the memory mapping open.
  51   if (errorHandler().outputBuffer)
  52     errorHandler().outputBuffer->discard();
  53
  54   // Dealloc/destroy ManagedStatic variables before calling
  55   // _exit(). In a non-LTO build, this is a nop. In an LTO
  56   // build allows us to get the output of -time-passes.
  57   llvm_shutdown();
  58
  59   outs().flush();
  60   errs().flush();
  61   _exit(val);
  62 }
  63
  64 void lld::diagnosticHandler(const DiagnosticInfo &di) {
  65   SmallString<128> s;
  66   raw_svector_ostream os(s);
  67   DiagnosticPrinterRawOStream dp(os);
  68   di.print(dp);
  69   switch (di.getSeverity()) {
  70   case DS_Error:
  71     error(s);
  72     break;
  73   case DS_Warning:
  74     warn(s);
  75     break;
  76   case DS_Remark:
  77   case DS_Note:
  78     message(s);
  79     break;
  80   }
  81 }
  82
  83 void lld::checkError(Error e) {
  84   handleAllErrors(std::move(e),
  85                   [&](ErrorInfoBase &eib) { error(eib.message()); });
  86 }
  87
  88 static std::string getLocation(std::string msg, std::string defaultMsg) {
  89   static std::vector<std::regex> Regexes{
  90       std::regex(R"(^undefined symbol:.*\n>>> referenced by (\S+):(\d+)\n.*)"),
  91       std::regex(R"(^undefined symbol:.*\n>>> referenced by (.*):)"),
  92       std::regex(
  93           R"(^duplicate symbol: .*\n>>> defined in (\S+)\n>>> defined in.*)"),
  94       std::regex(
  95           R"(^duplicate symbol: .*\n>>> defined at (\S+):(\d+).*)"),
  96       std::regex(
  97           R"(.*\n>>> defined in .*\n>>> referenced by (\S+):(\d+))"),
  98       std::regex(
  99           R"(^undefined (internal|hidden|protected) symbol: .*\n>>> referenced by (\S+):(\d+)\n.*)"),
 100       std::regex(R"((\S+):(\d+): unclosed quote)"),
 101   };
 102
 103   std::smatch Match;
 104   for (std::regex &Re : Regexes) {
 105     if (std::regex_search(msg, Match, Re)) {
 106       return Match.size() > 2 ? Match.str(1) + "(" + Match.str(2) + ")"
 107                               : Match.str(1);
 108     }
 109   }
 110   return defaultMsg;
 111 }
 112
 113 void ErrorHandler::printHeader(StringRef s, raw_ostream::Colors c,
 114                                const Twine &msg) {
 115
 116   if (vsDiagnostics) {
 117     // A Visual Studio-style error message starts with an error location.
 118     // If a location cannot be extracted then we default to LogName.
 119     *errorOS << getLocation(msg.str(), logName) << ": ";
 120   } else {
 121     *errorOS << logName << ": ";
 122   }
 123
 124   if (colorDiagnostics) {
 125     errorOS->changeColor(c, true);
 126     *errorOS << s;
 127     errorOS->resetColor();
 128   } else {
 129     *errorOS << s;
 130   }
 131 }
 132
 133 void ErrorHandler::log(const Twine &msg) {
 134   if (verbose) {
 135     std::lock_guard<std::mutex> lock(mu);
 136     *errorOS << logName << ": " << msg << "\n";
 137   }
 138 }
 139
 140 void ErrorHandler::message(const Twine &msg) {
 141   std::lock_guard<std::mutex> lock(mu);
 142   outs() << msg << "\n";
 143   outs().flush();
 144 }
 145
 146 void ErrorHandler::warn(const Twine &msg) {
 147   if (fatalWarnings) {
 148     error(msg);
 149     return;
 150   }
 151
 152   std::lock_guard<std::mutex> lock(mu);
 153   newline(errorOS, msg);
 154   printHeader("warning: ", raw_ostream::MAGENTA, msg);
 155   *errorOS << msg << "\n";
 156 }
 157
 158 void ErrorHandler::error(const Twine &msg) {
 159   std::lock_guard<std::mutex> lock(mu);
 160   newline(errorOS, msg);
 161
 162   if (errorLimit == 0 || errorCount < errorLimit) {
 163     printHeader("error: ", raw_ostream::RED, msg);
 164     *errorOS << msg << "\n";
 165   } else if (errorCount == errorLimit) {
 166     printHeader("error: ", raw_ostream::RED, msg);
 167     *errorOS << errorLimitExceededMsg << "\n";
 168     if (exitEarly)
 169       exitLld(1);
 170   }
 171
 172   ++errorCount;
 173 }
 174
 175 void ErrorHandler::fatal(const Twine &msg) {
 176   error(msg);
 177   exitLld(1);
 178 }