[lld] add ability to register exit handlers

[inglorion]

Summary

We have an exitLld() function that can be used to exit lld without
running the normal atexit() handlers, destructors, etc. In some cases,
there is still some code we need to run when lld exits. This patch
adds an addLldExitHandler() function which allows the registration
of handlers which will be run by exitLld(). It also moves exitLld()
into its own file.

[sbc100]

lld/Common/Exit.cpp

27

Maybe just to static instead of anon namespace here. This is what we do for freestanding functions.

50

I think the convention is not to wrap the whole .cpp file in namespace but to explicitly add it to each function impl.

lld/include/lld/Common/Exit.h

29

Seems a little strange to have lld in the function name here. I think lld::addExitHandler would be cleaner, but I can see you are following the convention of exitLld.

[inglorion]

Thanks for your suggestions, sbc. Those would be good to implement if we wanted the feature. However, we decided against the feature that depends on this, so I'll be abandoning this diff.

[inglorion]

We decided against shipping the feature that depends on this. Given that, I'd rather not have this code. Abandoning the diff.

lld/COFF/Driver.cpp

 #include "MarkLive.h"
 #include "MinGW.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Exit.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Timer.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/BinaryFormat/Magic.h"
 #include "llvm/Object/ArchiveWriter.h"
 #include "llvm/Object/COFFImportFile.h"

lld/Common/CMakeLists.txt

 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCommon
   Args.cpp
   ErrorHandler.cpp
+  Exit.cpp
   Memory.cpp
   Reproduce.cpp
   Strings.cpp
   TargetOptionsCommandFlags.cpp
   Threads.cpp
   Timer.cpp
   Version.cpp
 

lld/Common/ErrorHandler.cpp

 //===- ErrorHandler.cpp ---------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/ErrorHandler.h"
 
+#include "lld/Common/Exit.h"
 #include "lld/Common/Threads.h"
 
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/raw_ostream.h"
 #include <mutex>
 
-#if !defined(_MSC_VER) && !defined(__MINGW32__)
-#include <unistd.h>
-#endif
-
 using namespace llvm;
 using namespace lld;
 
 // The functions defined in this file can be called from multiple threads,
 // but outs() or errs() are not thread-safe. We protect them using a mutex.
 static std::mutex Mu;
 
 // Prints "\n" or does nothing, depending on Msg contents of
 // the previous call of this function.
 static void newline(raw_ostream *ErrorOS, const Twine &Msg) {
   // True if the previous error message contained "\n".
   // We want to separate multi-line error messages with a newline.
   static bool Flag;
 
   if (Flag)
     *ErrorOS << "\n";
   Flag = StringRef(Msg.str()).contains('\n');
 }
 
 ErrorHandler &lld::errorHandler() {
   static ErrorHandler Handler;
   return Handler;
 }
 
-void lld::exitLld(int Val) {
-  // Delete the output buffer so that any tempory file is deleted.
-  errorHandler().OutputBuffer.reset();
-
-  // 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 lld::diagnosticHandler(const DiagnosticInfo &DI) {
   SmallString<128> S;
   raw_svector_ostream OS(S);
   DiagnosticPrinterRawOStream DP(OS);
   DI.print(DP);
   warn(S);
 }
 

lld/Common/Exit.cpp

+//===- Exit.cpp - Exiting LLD -----------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lld/Common/Exit.h"
+
+#include "lld/Common/ErrorHandler.h"
+
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <functional>
+
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
+using namespace llvm;
+
+namespace {
+SmallVector<std::function<void()>, 4> ExitHandlers;
+} // anonymous namespace
+
+namespace lld {
+void addLldExitHandler(std::function<void()> &&Handler) {
+  ExitHandlers.push_back(Handler);
+}
+
+void exitLld(int Val) {
+  for (auto I = ExitHandlers.rbegin(); I != ExitHandlers.rend(); ++I)
+    (*I)();
+
+  // Delete the output buffer so that any tempory file is deleted.
+  errorHandler().OutputBuffer.reset();
+
+  // 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);
+}
+} // namespace lld

lld/ELF/Driver.cpp

 #include "SymbolTable.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/Driver.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Exit.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"

lld/include/lld/Common/ErrorHandler.h

 inline LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg) {
   errorHandler().fatal(Msg);
 }
 inline void log(const Twine &Msg) { errorHandler().log(Msg); }
 inline void message(const Twine &Msg) { errorHandler().message(Msg); }
 inline void warn(const Twine &Msg) { errorHandler().warn(Msg); }
 inline uint64_t errorCount() { return errorHandler().ErrorCount; }
 
-LLVM_ATTRIBUTE_NORETURN void exitLld(int Val);
-
 void diagnosticHandler(const llvm::DiagnosticInfo &DI);
 void checkError(Error E);
 
 // check functions are convenient functions to strip errors
 // from error-or-value objects.
 template <class T> T check(ErrorOr<T> E) {
   if (auto EC = E.getError())
     fatal(EC.message());

lld/include/lld/Common/Exit.h

+//===- Exit.h - Exiting LLD -------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// In LLD, we use the exitLld() function instead of exit(). This saves time
+// by not running most destructors.
+//
+// Because in rare cases we do want some code to run on exit, we also define
+// an interface for registering such code.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COMMON_EXIT_H
+#define LLD_COMMON_EXIT_H
+
+#include "llvm/Support/Compiler.h"
+
+#include <functional>
+
+namespace lld {
+
+/// Registers a function to be called when LLD exits.
+/// Functions are called in reverse order of registration.
+void addLldExitHandler(std::function<void()> &&Handler);
+
+LLVM_ATTRIBUTE_NORETURN void exitLld(int Val);
+
+} // namespace lld
+
+#endif

lld/lib/Driver/DarwinLdDriver.cpp

 /// \file
 ///
 /// Concrete instance of the Driver for darwin's ld.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Exit.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Core/ArchiveLibraryFile.h"
 #include "lld/Core/Error.h"
 #include "lld/Core/File.h"
 #include "lld/Core/Instrumentation.h"
 #include "lld/Core/LinkingContext.h"
 #include "lld/Core/Node.h"
 #include "lld/Core/PassManager.h"

lld/wasm/Driver.cpp

 #include "Config.h"
 #include "InputChunks.h"
 #include "InputGlobal.h"
 #include "MarkLive.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Exit.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "lld/Common/Threads.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Support/CommandLine.h"