[FOR DEMO] Wait for all threads before exitting.

[ruiu]

Summary

[FOR DEMO] Wait for all threads before exitting.

lld/trunk/ELF/CMakeLists.txt

add_lld_library(lldELF
   Relocations.cpp
   ScriptLexer.cpp
   ScriptParser.cpp
   Strings.cpp
   SymbolTable.cpp
   Symbols.cpp
   SyntheticSections.cpp
   Target.cpp
+  Threads.cpp
   Thunks.cpp
   Writer.cpp
 
   LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   Analysis
   BinaryFormat
   BitReader

lld/trunk/ELF/Driver.cpp

bool elf::link(ArrayRef<const char *> Args, bool CanExitEarly,
 
   Config = make<Configuration>();
   Driver = make<LinkerDriver>();
   Script = make<LinkerScript>();
   Symtab = make<SymbolTable>();
   Config->Argv = {Args.begin(), Args.end()};
 
   Driver->main(Args, CanExitEarly);
+  waitForBackgroundThreads();
 
   // Exit immediately if we don't need to return to the caller.
   // This saves time because the overhead of calling destructors
   // for all globally-allocated objects is not negligible.
   if (Config->ExitEarly)
     exitLld(ErrorCount ? 1 : 0);
 
   freeArena();

lld/trunk/ELF/Error.cpp

 //===- Error.cpp ----------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Error.h"
 #include "Config.h"
+#include "Threads.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <mutex>
 
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
if (Config->ErrorLimit == 0 || ErrorCount < Config->ErrorLimit) {
     if (Config->ExitEarly)
       exitLld(1);
   }
 
   ++ErrorCount;
 }
 
 void elf::exitLld(int Val) {
+  waitForBackgroundThreads();
+
   // Dealloc/destroy ManagedStatic variables before calling
   // _exit(). In a non-LTO build, this is a nop. In an LTO
   // build allows us to get the output of -time-passes.
   llvm_shutdown();
 
   outs().flush();
   errs().flush();
   _exit(Val);
 }
 
 void elf::fatal(const Twine &Msg) {
   error(Msg);
   exitLld(1);
 }

lld/trunk/ELF/Filesystem.cpp

 //===- Filesystem.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains a few utility functions to handle files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Filesystem.h"
 #include "Config.h"
-#include "llvm/Support/FileSystem.h"
+#include "Threads.h"
 #include "llvm/Support/FileOutputBuffer.h"
-#include <thread>
+#include "llvm/Support/FileSystem.h"
 
 using namespace llvm;
 
 using namespace lld;
 using namespace lld::elf;
 
 // Removes a given file asynchronously. This is a performance hack,
 // so remove this when operating systems are improved.
void elf::unlinkAsync(StringRef Path) {
   if (sys::fs::createUniqueFile(Path + "tmp%%%%%%%%", TempPath))
     return;
   if (sys::fs::rename(Path, TempPath)) {
     sys::fs::remove(TempPath);
     return;
   }
 
   // Remove TempPath in background.
-  std::thread([=] { ::remove(TempPath.str().str().c_str()); }).detach();
+  runBackground([=] { ::remove(TempPath.str().str().c_str()); });
 }
 
 // Simulate file creation to see if Path is writable.
 //
 // Determining whether a file is writable or not is amazingly hard,
 // and after all the only reliable way of doing that is to actually
 // create a file. But we don't want to do that in this function
 // because LLD shouldn't update any file if it will end in a failure.

lld/trunk/ELF/Threads.h

 
 inline void parallelForEachN(size_t Begin, size_t End,
                              std::function<void(size_t)> Fn) {
   if (Config->Threads)
     for_each_n(llvm::parallel::par, Begin, End, Fn);
   else
     for_each_n(llvm::parallel::seq, Begin, End, Fn);
 }
+
+void runBackground(std::function<void()> Fn);
+void waitForBackgroundThreads();
+
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/Threads.cpp

+//===- Threads.cpp --------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Threads.h"
+#include <thread>
+
+static std::vector<std::thread> Threads;
+
+// Runs a given function in a new thread.
+void lld::elf::runBackground(std::function<void()> Fn) {
+  Threads.emplace_back(Fn);
+}
+
+// Wait for all threads spawned for runBackground() to finish.
+//
+// You need to call this function from the main thread before exiting
+// because it is not defined what will happen to non-main threads when
+// the main thread exits.
+void lld::elf::waitForBackgroundThreads() {
+  for (std::thread &T : Threads)
+    if (T.joinable())
+      T.join();
+}