[ThinLTO] Fix nondeterministic exit on error.

[mtrofin]

Summary

In the multi-threaded case, if a thread hits an error, we mimick LLVMContext's behavior of reporting the error and exit-ing. However, this doesn't cleanly join the other threads, so depending on how fast the process exits, other threads may report 'terminate called without an active exception'.

To avoid this non-determinsim, and without introducing a more complicated design, we just report the error, but not exit early. We do track whether we hit errors and exit(1) after joining.

[tejohnson]

llvm/tools/llvm-lto2/llvm-lto2.cpp

311

Or if Threads==1

327

What is the downside of always deferring the error?

[mtrofin]

simplified by handling single and multithreaded error cases the same way

[mtrofin]

llvm/tools/llvm-lto2/llvm-lto2.cpp

311

ack, but not needed anymore

327

Just that we can exit quicker in that case, and it'd mimic what clang does in non-multi-threaded cases. But I don't think either of those are worth the extra check, so removing the singlethreaded special case.

[tejohnson]

lgtm with one minor suggestion below.

llvm/tools/llvm-lto2/llvm-lto2.cpp

324

Nit: The last 3 lines can now be shortened to 2:

if (DI.getSeverity() == DS_Error)
   HasErrors = true;

[mtrofin]

feedback

llvm/tools/llvm-lto2/llvm-lto2.cpp

 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/Caching.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/PluginLoader.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Threading.h"
+#include <atomic>
 
 using namespace llvm;
 using namespace lto;
 
 static codegen::RegisterCodeGenFlags CGF;
 
 static cl::opt<char>
     OptLevel("O", cl::desc("Optimization level. [-O0, -O1, -O2, or -O3] "
for (std::string R : SymbolResolutions) {
     }
     CommandLineResolutions[{std::string(FileName), std::string(SymbolName)}]
         .push_back(Res);
   }
 
   std::vector<std::unique_ptr<MemoryBuffer>> MBs;
 
   Config Conf;
-  Conf.DiagHandler = [](const DiagnosticInfo &DI) {
-    DiagnosticPrinterRawOStream DP(errs());
-    DI.print(DP);
-    errs() << '\n';
-    if (DI.getSeverity() == DS_Error)
-      exit(1);
-  };
 
   Conf.CPU = codegen::getMCPU();
   Conf.Options = codegen::InitTargetOptionsFromCodeGenFlags(Triple());
   Conf.MAttrs = codegen::getMAttrs();
   if (auto RM = codegen::getExplicitRelocModel())
     Conf.RelocModel = RM.getValue();
   Conf.CodeModel = codegen::getExplicitCodeModel();
 
if (ThinLTODistributedIndexes)
     Backend = createWriteIndexesThinBackend(/* OldPrefix */ "",
                                             /* NewPrefix */ "",
                                             /* ShouldEmitImportsFiles */ true,
                                             /* LinkedObjectsFile */ nullptr,
                                             /* OnWrite */ {});
   else
     Backend = createInProcessThinBackend(
         llvm::heavyweight_hardware_concurrency(Threads));
+  const bool SingleThreaded = ThinLTODistributedIndexes;
+  // Track whether we hit an error; in particular, in the multi-threaded case,
+  // we can't exit() early because the rest of the threads wouldn't have had a
+  // change to be join-ed, and that would result in a "terminate called without
+  // an active exception". Altogether, this results in nondeterministic
+  // behavior. Instead, we don't exit in the multi-threaded case, but we make
+  // sure to report the error and then at the end (after joining cleanly)
+  // exit(1).
+  std::atomic<bool> HasErrors;
+  std::atomic_init(&HasErrors, false);
+  Conf.DiagHandler = [&](const DiagnosticInfo &DI) {
+    DiagnosticPrinterRawOStream DP(errs());
+    DI.print(DP);
+    errs() << '\n';
+    if (DI.getSeverity() != DS_Error)
+      return;
+    if (SingleThreaded)
+      exit(1);
+    else
+      HasErrors = true;
+  };
+
   LTO Lto(std::move(Conf), std::move(Backend));
 
-  bool HasErrors = false;
   for (std::string F : InputFilenames) {
     std::unique_ptr<MemoryBuffer> MB = check(MemoryBuffer::getFile(F), F);
     std::unique_ptr<InputFile> Input =
         check(InputFile::create(MB->getMemBufferRef()), F);
 
     std::vector<SymbolResolution> Res;
     for (const InputFile::Symbol &Sym : Input->symbols()) {
       auto I = CommandLineResolutions.find({F, std::string(Sym.getName())});
static int run(int argc, char **argv) {
   };
 
   FileCache Cache;
   if (!CacheDir.empty())
     Cache = check(localCache("ThinLTO", "Thin", CacheDir, AddBuffer),
                   "failed to create cache");
 
   check(Lto.run(AddStream, Cache), "LTO::run failed");
-  return 0;
+  return static_cast<int>(HasErrors);
 }
 
 static int dumpSymtab(int argc, char **argv) {
   for (StringRef F : make_range(argv + 1, argv + argc)) {
     std::unique_ptr<MemoryBuffer> MB =
         check(MemoryBuffer::getFile(F), std::string(F));
     BitcodeFileContents BFC =
         check(getBitcodeFileContents(*MB), std::string(F));