ManagedStatic: Destroy from destructor

[nhaehnle]

Summary

This allows LLVM to be safely loaded and unloaded as a shared library
without leaking memory:

Consider the scenario where shared library Foo links against LLVM as
a shared library, and Foo may be loaded and unloaded multiple times
in the same process. Should Foo call llvm_shutdown or not? If it does
not, and LLVM is also loaded and unloaded multiple times, then
memory is leaked. If it does call llvm_shutdown and LLVM *isn't*
also unloaded, the state of LLVM's global statics is corrupted because
while the ManagedStatics may be re-initialized, *other* global
constructors aren't re-run.

Keep in mind that Foo itself may use ManagedStatic. If Foo is unloaded
but LLVM isn't, those statics should be destroyed.

The safe solution is to skip llvm_shutdown() altogether and destroy
managed statics from their destructor.

LLD relies on being able to call _exit() and still get some side-effects
of managed static destructors. We make this expectation much more
explicit.

[nhaehnle]

Abandoning this in favor of removing ManagedStatic entirely via the stack of changes that ends in D129134

bolt/tools/driver/llvm-bolt.cpp

static std::string GetExecutablePath(const char *Argv0) {
   return std::string(ExecutablePath.str());
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
   std::string ToolPath = GetExecutablePath(argv[0]);
 
   // Initialize targets and assembly printers/parsers.
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
   llvm::InitializeAllDisassemblers();
 

bolt/tools/merge-fdata/merge-fdata.cpp

 
 } // anonymous namespace
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
 
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
   cl::HideUnrelatedOptions(opts::MergeFdataCategory);
 
   cl::ParseCommandLineOptions(argc, argv,
                               "merge multiple fdata into a single file");
 
   ToolName = argv[0];
 
   // Recursively expand input directories into input file lists.

clang/include/clang/Frontend/CompilerInstance.h

public:
   ///  - The diagnostics engine should have already been created by the client.
   ///
   ///  - No other CompilerInstance state should have been initialized (this is
   ///    an unchecked error).
   ///
   ///  - Clients should have initialized any LLVM target features that may be
   ///    required.
   ///
-  ///  - Clients should eventually call llvm_shutdown() upon the completion of
-  ///    this routine to ensure that any managed objects are properly destroyed.
-  ///
   /// Note that this routine may write output to 'stderr'.
   ///
   /// \param Act - The action to execute.
   /// \return - True on success.
-  //
-  // FIXME: Eliminate the llvm_shutdown requirement, that should either be part
-  // of the context or else not CompilerInstance specific.
   bool ExecuteAction(FrontendAction &Act);
 
   /// Load the list of plugins requested in the \c FrontendOptions.
   void LoadRequestedPlugins();
 
   /// }
   /// @name Compiler Invocation and Options
   /// {

clang/tools/clang-repl/ClangRepl.cpp

 #include "clang/Basic/Diagnostic.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/FrontendDiagnostic.h"
 #include "clang/Interpreter/Interpreter.h"
 
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/LineEditor/LineEditor.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h" // llvm_shutdown
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h" // llvm::Initialize*
 
 static llvm::cl::list<std::string>
     ClangArgs("Xcc",
               llvm::cl::desc("Argument to pass to the CompilerInvocation"),
               llvm::cl::CommaSeparated);
 static llvm::cl::opt<bool> OptHostSupportsJit("host-supports-jit",
if (OptInputs.empty()) {
     }
   }
 
   // Our error handler depends on the Diagnostics object, which we're
   // potentially about to delete. Uninstall the handler now so that any
   // later errors use the default handling behavior instead.
   llvm::remove_fatal_error_handler();
 
-  llvm::llvm_shutdown();
-
   return 0;
 }

clang/unittests/Interpreter/ExceptionTests/InterpreterExceptionTest.cpp

extern "C" int throw_exception() {
 
   llvm::cantFail(Interp->ParseAndExecute(ExceptionCode));
   testing::internal::CaptureStdout();
   auto ThrowException =
       (int (*)())llvm::cantFail(Interp->getSymbolAddress("throw_exception"));
   EXPECT_ANY_THROW(ThrowException());
   std::string CapturedStdOut = testing::internal::GetCapturedStdout();
   EXPECT_EQ(CapturedStdOut, "Caught: 'To be caught in JIT'\n");
-
-  llvm::llvm_shutdown();
 }
 
 } // end anonymous namespace

clang/unittests/Interpreter/InterpreterTest.cpp

static std::string MangleName(NamedDecl *ND) {
   return RawStr.str();
 }
 
 struct LLVMInitRAII {
   LLVMInitRAII() {
     llvm::InitializeNativeTarget();
     llvm::InitializeNativeTargetAsmPrinter();
   }
-  ~LLVMInitRAII() { llvm::llvm_shutdown(); }
 } LLVMInit;
 
 #ifdef _AIX
 TEST(IncrementalProcessing, DISABLED_FindMangledNameSymbol) {
 #else
 TEST(IncrementalProcessing, FindMangledNameSymbol) {
 #endif
 

clang/utils/TableGen/TableGen.cpp

 }
 }
 
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
 
-  llvm_shutdown_obj Y;
-
   return TableGenMain(argv[0], &ClangTableGenMain);
 }
 
 #ifdef __has_feature
 #if __has_feature(address_sanitizer)
 #include <sanitizer/lsan_interface.h>
 // Disable LeakSanitizer for this binary as it has too many leaks that are not
 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
 int __lsan_is_turned_off() { return 1; }
 #endif  // __has_feature(address_sanitizer)
 #endif  // defined(__has_feature)

libclc/utils/prepare-builtins.cpp

 InputFilename(cl::Positional, cl::desc("<input bitcode>"), cl::init("-"));
 
 static cl::opt<std::string>
 OutputFilename("o", cl::desc("Output filename"),
                cl::value_desc("filename"));
 
 int main(int argc, char **argv) {
   LLVMContext Context;
-  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   cl::ParseCommandLineOptions(argc, argv, "libclc builtin preparation tool\n");
 
   std::string ErrorMessage;
   Module *M = nullptr;
 
   {
     ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =

lld/Common/ErrorHandler.cpp

 
 #include "llvm/Support/Parallel.h"
 
 #include "lld/Common/CommonLinkerContext.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/Support/CrashRecoveryContext.h"
-#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/FastShutdown.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Program.h"
 #include "llvm/Support/raw_ostream.h"
 #include <regex>
 
 using namespace llvm;
 using namespace lld;
 
if (hasContext()) {
     if (e.outputBuffer)
       e.outputBuffer->discard();
   }
 
   // Re-throw a possible signal or exception once/if it was catched by
   // safeLldMain().
   CrashRecoveryContext::throwIfCrash(val);
 
-  // Dealloc/destroy ManagedStatic variables before calling _exit().
-  // In an LTO build, allows us to get the output of -time-passes.
-  // Ensures that the thread pool for the parallel algorithms is stopped to
-  // avoid intermittent crashes on Windows when exiting.
+  // We will call _exit() but want to get the output of -time-passes in an LTO
+  // build. Also ensures that the thread pool for the parallel algorithms is
+  // stopped to avoid intermittent crashes on Windows when exiting.
   if (!CrashRecoveryContext::GetCurrent())
-    llvm_shutdown();
+    llvm_fast_shutdown();
 
   if (hasContext())
     lld::errorHandler().flushStreams();
 
   // When running inside safeLldMain(), restore the control flow back to the
   // CrashRecoveryContext. Otherwise simply use _exit(), meanning no cleanup,
   // since we want to avoid further crashes on shutdown.
   llvm::sys::Process::Exit(val, /*NoCleanup=*/true);

lldb/tools/driver/Driver.cpp

static llvm::Optional<int> InitializeReproducer(llvm::StringRef argv0,
   return llvm::None;
 }
 
 int main(int argc, char const *argv[]) {
   // Editline uses for example iswprint which is dependent on LC_CTYPE.
   std::setlocale(LC_ALL, "");
   std::setlocale(LC_CTYPE, "");
 
-  // Setup LLVM signal handlers and make sure we call llvm_shutdown() on
-  // destruction.
+  // Setup LLVM signal handlers.
   llvm::InitLLVM IL(argc, argv, /*InstallPipeSignalExitHandler=*/false);
 
   // Parse arguments.
   LLDBOptTable T;
   unsigned MissingArgIndex;
   unsigned MissingArgCount;
   ArrayRef<const char *> arg_arr = makeArrayRef(argv + 1, argc - 1);
   opt::InputArgList input_args =

lldb/tools/lldb-test/lldb-test.cpp

int opts::assert::lldb_assert(Debugger &Dbg) {
   lldbassert(false && "lldb-test assert");
   return 1;
 }
 
 int main(int argc, const char *argv[]) {
   StringRef ToolName = argv[0];
   sys::PrintStackTraceOnErrorSignal(ToolName);
   PrettyStackTraceProgram X(argc, argv);
-  llvm_shutdown_obj Y;
 
   cl::ParseCommandLineOptions(argc, argv, "LLDB Testing Utility\n");
 
   SystemLifetimeManager DebuggerLifetime;
   if (auto e = DebuggerLifetime.Initialize(
           std::make_unique<SystemInitializerTest>(), nullptr)) {
     WithColor::error() << "initialization failed: " << toString(std::move(e))
                        << '\n';

lldb/unittests/Utility/LogTest.cpp

struct LogChannelTest : public ::testing::Test {
   void TearDown() override { Log::DisableAllLogChannels(); }
 
   static void SetUpTestCase() {
     Log::Register("chan", test_channel);
   }
 
   static void TearDownTestCase() {
     Log::Unregister("chan");
-    llvm::llvm_shutdown();
   }
 };
 
 // A test fixture which provides tests with a pre-registered and pre-enabled
 // channel. Additionally, the messages written to that channel are captured and
 // made available via getMessage().
 class LogChannelEnabledTest : public LogChannelTest {
   llvm::SmallString<0> m_messages;

 }
 
 TEST(LogTest, LLDB_LOG_nullptr) {
   Log *log = nullptr;
   LLDB_LOG(log, "{0}", 0); // Shouldn't crash
 }
 
 TEST(LogTest, Register) {
-  llvm::llvm_shutdown_obj obj;
   Log::Register("chan", test_channel);
   Log::Unregister("chan");
   Log::Register("chan", test_channel);
   Log::Unregister("chan");
 }
 
 TEST(LogTest, Unregister) {
-  llvm::llvm_shutdown_obj obj;
   Log::Register("chan", test_channel);
   EXPECT_EQ(nullptr, GetLog(TestChannel::FOO));
   std::string message;
   std::shared_ptr<llvm::raw_string_ostream> stream_sp(
       new llvm::raw_string_ostream(message));
   EXPECT_TRUE(Log::EnableLogChannel(stream_sp, 0, "chan", {"foo"}, llvm::nulls()));
   EXPECT_NE(nullptr, GetLog(TestChannel::FOO));
   Log::Unregister("chan");

lldb/utils/TableGen/LLDBTableGen.cpp

static bool LLDBTableGenMain(raw_ostream &OS, RecordKeeper &Records) {
   return false;
 }
 
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
   cl::ParseCommandLineOptions(argc, argv);
 
-  llvm_shutdown_obj Y;
-
   return TableGenMain(argv[0], &LLDBTableGenMain);
 }
 
 #ifdef __has_feature
 #if __has_feature(address_sanitizer)
 #include <sanitizer/lsan_interface.h>
 // Disable LeakSanitizer for this binary as it has too many leaks that are not
 // very interesting to fix. See compiler-rt/include/sanitizer/lsan_interface.h .
 int __lsan_is_turned_off() { return 1; }
 #endif // __has_feature(address_sanitizer)
 #endif // defined(__has_feature)

llvm/docs/ProgrammersManual.rst

 
 Note that, on Unix-like platforms, LLVM requires the presence of GCC's atomic
 intrinsics in order to support threaded operation.  If you need a
 multithreading-capable LLVM on a platform without a suitably modern system
 compiler, consider compiling LLVM and LLVM-GCC in single-threaded mode, and
 using the resultant compiler to build a copy of LLVM with multithreading
 support.
 
-.. _shutdown:
-
-Ending Execution with ``llvm_shutdown()``
------------------------------------------
-
-When you are done using the LLVM APIs, you should call ``llvm_shutdown()`` to
-deallocate memory used for internal structures.
-
 .. _managedstatic:
 
 Lazy Initialization with ``ManagedStatic``
 ------------------------------------------
 
 ``ManagedStatic`` is a utility class in LLVM used to implement static
 initialization of static resources, such as the global type tables.  In a
 single-threaded environment, it implements a simple lazy initialization scheme.

llvm/examples/BrainF/BrainFDriver.cpp

int main(int argc, char **argv) {
   } else {
     WriteBitcodeToFile(*Mod, *out);
   }
 
   //Clean up
   if (out != &outs())
     delete out;
 
-  llvm_shutdown();
-
   return 0;
 }

llvm/examples/HowToUseJIT/HowToUseJIT.cpp

int main() {
 
   // Call the `foo' function with no arguments:
   std::vector<GenericValue> noargs;
   GenericValue gv = EE->runFunction(FooF, noargs);
 
   // Import result of execution:
   outs() << "Result: " << gv.IntVal << "\n";
   delete EE;
-  llvm_shutdown();
   return 0;
 }

llvm/include/llvm-c/Core.h

 typedef unsigned LLVMAttributeIndex;
 
 /**
  * @}
  */
 
 void LLVMInitializeCore(LLVMPassRegistryRef R);
 
-/** Deallocate and destroy all ManagedStatic variables.
-    @see llvm::llvm_shutdown
-    @see ManagedStatic */
-void LLVMShutdown(void);
+LLVM_ATTRIBUTE_C_DEPRECATED(
+    void LLVMShutdown(void),
+    "This is a no-op; destruction of ManagedStatic variables now happens by "
+    "default");
 
 /*===-- Error handling ----------------------------------------------------===*/
 
 char *LLVMCreateMessage(const char *Message);
 void LLVMDisposeMessage(char *Message);
 
 /**
  * @defgroup LLVMCCoreContext Contexts

llvm/include/llvm/ADT/Statistic.h

 //===-- llvm/ADT/Statistic.h - Easy way to expose stats ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// This file defines the 'Statistic' class, which is designed to be an easy way
 /// to expose various metrics from passes.  These statistics are printed at the
-/// end of a run (from llvm_shutdown), when the -stats command line option is
-/// passed on the command line.
+/// end of a run (during cleanup of ManagedStatics), when the -stats command
+/// line option is passed on the command line.
 ///
 /// This is useful for reporting information like the number of instructions
 /// simplified, optimized or removed by various transformations, like this:
 ///
 /// static Statistic NumInstsKilled("gcse", "Number of instructions killed");
 ///
 /// Later, in the code: ++NumInstsKilled;
 ///

llvm/include/llvm/PassRegistry.h

class PassRegistry {
   std::vector<std::unique_ptr<const PassInfo>> ToFree;
   std::vector<PassRegistrationListener *> Listeners;
 
 public:
   PassRegistry() = default;
   ~PassRegistry();
 
   /// getPassRegistry - Access the global registry object, which is
-  /// automatically initialized at application launch and destroyed by
-  /// llvm_shutdown.
+  /// automatically initialized at application launch and destroyed when
+  /// global destructors are run.
   static PassRegistry *getPassRegistry();
 
   /// getPassInfo - Look up a pass' corresponding PassInfo, indexed by the pass'
   /// type identifier (&MyPass::ID).
   const PassInfo *getPassInfo(const void *TI) const;
 
   /// getPassInfo - Look up a pass' corresponding PassInfo, indexed by the pass'
   /// argument string.

llvm/include/llvm/Support/DynamicLibrary.h

public:
     /// found, the address of that symbol is returned. If not, NULL is returned.
     /// Note that NULL will also be returned if the library failed to load.
     /// Use isValid() to distinguish these cases if it is important.
     /// Note that this will \e not search symbols explicitly registered by
     /// AddSymbol().
     void *getAddressOfSymbol(const char *symbolName);
 
     /// This function permanently loads the dynamic library at the given path.
-    /// The library will only be unloaded when llvm_shutdown() is called.
+    /// The library will only be unloaded when LLVM's global destructors are
+    /// run.
     /// This returns a valid DynamicLibrary instance on success and an invalid
     /// instance on failure (see isValid()). \p *errMsg will only be modified
     /// if the library fails to load.
     ///
     /// It is safe to call this function multiple times for the same library.
     /// Open a dynamic library permanently.
     static DynamicLibrary getPermanentLibrary(const char *filename,
                                               std::string *errMsg = nullptr);

llvm/include/llvm/Support/FastShutdown.h

+//===-- llvm/Support/FastShutdown.h -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Helpers to allow a fast process shutdown without the normal cleanups
+// (e.g., using _exit) but with some desirable side-effects that usually happen
+// when global static destructors are run.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_SUPPORT_FASTSHUTDOWN_H
+#define LLVM_SUPPORT_FASTSHUTDOWN_H
+
+namespace llvm {
+
+/// Run a small set of operations that usually run from global static
+/// destructors, but which have side-effects (e.g., printing statistics) that
+/// are desirable for tools that want to do a fast process exit without cleanups
+/// (e.g., using _exit).
+///
+/// Note that if the process exits (or LLVM is unloaded) normally, calling this
+/// function isn't necessary and should be avoided.
+///
+/// IMPORTANT: It's only safe to call llvm_fast_shutdown() in a single thread,
+/// without any other threads executing LLVM APIs. No LLVM APIs should be used
+/// after calling this function (other than sys::Process::Exit).
+void llvm_fast_shutdown();
+
+void fast_shutdown_statistics();
+void fast_shutdown_parallel();
+
+} // namespace llvm
+
+#endif // LLVM_SUPPORT_FASTSHUTDOWN_H

llvm/include/llvm/Support/InitLLVM.h

 //  2. Set up the global new-handler which is called when a memory allocation
 //     attempt fails.
 //
 //  3. If running on Windows, obtain command line arguments using a
 //     multibyte character-aware API and convert arguments into UTF-8
 //     encoding, so that you can assume that command line arguments are
 //     always encoded in UTF-8 on any platform.
 //
-// InitLLVM calls llvm_shutdown() on destruction, which cleans up
-// ManagedStatic objects.
 namespace llvm {
 class InitLLVM {
 public:
   InitLLVM(int &Argc, const char **&Argv,
            bool InstallPipeSignalExitHandler = true);
   InitLLVM(int &Argc, char **&Argv, bool InstallPipeSignalExitHandler = true)
       : InitLLVM(Argc, const_cast<const char **&>(Argv),
                  InstallPipeSignalExitHandler) {}
 
-  ~InitLLVM();
-
 private:
   BumpPtrAllocator Alloc;
   SmallVector<const char *, 0> Args;
   Optional<PrettyStackTraceProgram> StackPrinter;
 };
 } // namespace llvm
 
 #endif

llvm/include/llvm/Support/ManagedStatic.h

 //===-- llvm/Support/ManagedStatic.h - Static Global wrapper ----*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file defines the ManagedStatic class and the llvm_shutdown() function.
+// This file defines the ManagedStatic class.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MANAGEDSTATIC_H
 #define LLVM_SUPPORT_MANAGEDSTATIC_H
 
 #include <atomic>
 #include <cstddef>

 #define LLVM_USE_CONSTEXPR_CTOR
 #endif
 
 /// ManagedStaticBase - Common base class for ManagedStatic instances.
 class ManagedStaticBase {
 protected:
 #ifdef LLVM_USE_CONSTEXPR_CTOR
   mutable std::atomic<void *> Ptr{};
-  mutable void (*DeleterFn)(void *) = nullptr;
-  mutable const ManagedStaticBase *Next = nullptr;
 #else
   // This should only be used as a static variable, which guarantees that this
   // will be zero initialized.
   mutable std::atomic<void *> Ptr;
-  mutable void (*DeleterFn)(void *);
-  mutable const ManagedStaticBase *Next;
 #endif
 
-  void RegisterManagedStatic(void *(*creator)(), void (*deleter)(void*)) const;
+  void create(void *(*creator)()) const;
 
 public:
 #ifdef LLVM_USE_CONSTEXPR_CTOR
   constexpr ManagedStaticBase() = default;
 #endif
 
   /// isConstructed - Return true if this object has not been created yet.
   bool isConstructed() const { return Ptr != nullptr; }
-
-  void destroy() const;
 };
 
 /// ManagedStatic - This transparently changes the behavior of global statics to
 /// be lazily constructed on demand (good for reducing startup times of dynamic
-/// libraries that link in LLVM components) and for making destruction be
-/// explicit through the llvm_shutdown() function call.
+/// libraries that link in LLVM components).
 ///
 template <class C, class Creator = object_creator<C>,
           class Deleter = object_deleter<C>>
 class ManagedStatic : public ManagedStaticBase {
 public:
+  ~ManagedStatic() { destroy(); }
+
+  /// Destroy the managed static if it has been constructed.
+  ///
+  /// IMPORTANT: This must only be called from a single thread when it is known
+  ///            that no other thread accesses managed statics.
+  void destroy() {
+    if (isConstructed()) {
+      Deleter::call(Ptr.load(std::memory_order_relaxed));
+      Ptr = nullptr;
+    }
+  }
+
   // Accessors.
   C &operator*() {
     void *Tmp = Ptr.load(std::memory_order_acquire);
     if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
+      create(Creator::call);
 
     return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
   }
 
   C *operator->() { return &**this; }
 
+  // Retrieve the managed static or nullptr if it has not been initialized. This
+  // is useful in code run from global destructors where the order of
+  // destructors cannot be guaranteed.
+  C *peek() { return static_cast<C *>(Ptr.load(std::memory_order_relaxed)); }
+
   const C &operator*() const {
     void *Tmp = Ptr.load(std::memory_order_acquire);
     if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
+      create(Creator::call);
 
     return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
   }
 
   const C *operator->() const { return &**this; }
 
+  // Retrieve the managed static or nullptr if it has not been initialized. This
+  // is useful in code run from global destructors where the order of
+  // destructors cannot be guaranteed.
+  const C *peek() const {
+    return static_cast<C *>(Ptr.load(std::memory_order_relaxed));
+  }
+
   // Extract the instance, leaving the ManagedStatic uninitialized. The
   // user is then responsible for the lifetime of the returned instance.
   C *claim() {
     return static_cast<C *>(Ptr.exchange(nullptr));
   }
 };
 
-/// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
-void llvm_shutdown();
+[[deprecated("llvm_shutdown is a no-op; shutdown now happens by "
+             "default")]] static inline void
+llvm_shutdown() {}
 
-/// llvm_shutdown_obj - This is a simple helper class that calls
-/// llvm_shutdown() when it is destroyed.
-struct llvm_shutdown_obj {
-  llvm_shutdown_obj() = default;
-  ~llvm_shutdown_obj() { llvm_shutdown(); }
-};
+struct [[deprecated("llvm_shutdown_obj is a no-op; shutdown now happens by "
+                    "default")]] llvm_shutdown_obj{};
 
 } // end namespace llvm
 
 #endif // LLVM_SUPPORT_MANAGEDSTATIC_H

llvm/lib/IR/Core.cpp

void llvm::initializeCore(PassRegistry &Registry) {
   initializeSafepointIRVerifierPass(Registry);
   initializeVerifierLegacyPassPass(Registry);
 }
 
 void LLVMInitializeCore(LLVMPassRegistryRef R) {
   initializeCore(*unwrap(R));
 }
 
-void LLVMShutdown() {
-  llvm_shutdown();
-}
+// Deprecated.
+void LLVMShutdown() {}
 
 /*===-- Error handling ----------------------------------------------------===*/
 
 char *LLVMCreateMessage(const char *Message) {
   return strdup(Message);
 }
 
 void LLVMDisposeMessage(char *Message) {

llvm/lib/IR/Pass.cpp

 }
 
 PassNameParser::PassNameParser(cl::Option &O)
     : cl::parser<const PassInfo *>(O) {
   PassRegistry::getPassRegistry()->addRegistrationListener(this);
 }
 
 // This only gets called during static destruction, in which case the
-// PassRegistry will have already been destroyed by llvm_shutdown().  So
-// attempting to remove the registration listener is an error.
+// PassRegistry may have already been destroyed. So attempting to remove the
+// registration listener is an error (and also unnecessary).
 PassNameParser::~PassNameParser() = default;
 
 //===----------------------------------------------------------------------===//
 //   AnalysisUsage Class Implementation
 //
 
 namespace {
 

llvm/lib/IR/PassRegistry.cpp

 #include "llvm/PassInfo.h"
 #include "llvm/Support/ManagedStatic.h"
 #include <cassert>
 #include <memory>
 #include <utility>
 
 using namespace llvm;
 
-// FIXME: We use ManagedStatic to erase the pass registrar on shutdown.
-// Unfortunately, passes are registered with static ctors, and having
-// llvm_shutdown clear this map prevents successful resurrection after
-// llvm_shutdown is run.  Ideally we should find a solution so that we don't
-// leak the map, AND can still resurrect after shutdown.
 static ManagedStatic<PassRegistry> PassRegistryObj;
 PassRegistry *PassRegistry::getPassRegistry() {
   return &*PassRegistryObj;
 }
 
 //===----------------------------------------------------------------------===//
 // Accessors
 //

llvm/lib/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   DivisionByConstantInfo.cpp
   DAGDeltaAlgorithm.cpp
   DJB.cpp
   ELFAttributeParser.cpp
   ELFAttributes.cpp
   Error.cpp
   ErrorHandling.cpp
   ExtensibleRTTI.cpp
+  FastShutdown.cpp
   FileCollector.cpp
   FileUtilities.cpp
   FileOutputBuffer.cpp
   FoldingSet.cpp
   FormattedStream.cpp
   FormatVariadic.cpp
   GlobPattern.cpp
   GraphWriter.cpp

llvm/lib/Support/FastShutdown.cpp

+//===-- FastShutdown.cpp --------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Support/FastShutdown.h"
+
+using namespace llvm;
+
+void llvm::llvm_fast_shutdown() {
+  fast_shutdown_statistics();
+  fast_shutdown_parallel();
+}

llvm/lib/Support/InitLLVM.cpp

#ifdef _WIN32
   // GetCommandLineArguments doesn't terminate the vector with a
   // nullptr.  Do it to make it compatible with the real argv.
   Args.push_back(nullptr);
 
   Argc = Args.size() - 1;
   Argv = Args.data();
 #endif
 }
-
-InitLLVM::~InitLLVM() { llvm_shutdown(); }

llvm/lib/Support/ManagedStatic.cpp

 //===-- ManagedStatic.cpp - Static Global wrapper -------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// This file implements the ManagedStatic class and llvm_shutdown().
+// This file implements the ManagedStatic class.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/Threading.h"
 #include <cassert>
 #include <mutex>
 using namespace llvm;
 
-static const ManagedStaticBase *StaticList = nullptr;
-
 static std::recursive_mutex *getManagedStaticMutex() {
   static std::recursive_mutex m;
   return &m;
 }
 
-void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
-                                              void (*Deleter)(void*)) const {
+void ManagedStaticBase::create(void *(*Creator)()) const {
   assert(Creator);
   if (llvm_is_multithreaded()) {
     std::lock_guard<std::recursive_mutex> Lock(*getManagedStaticMutex());
 
     if (!Ptr.load(std::memory_order_relaxed)) {
       void *Tmp = Creator();
 
       Ptr.store(Tmp, std::memory_order_release);
-      DeleterFn = Deleter;
-
-      // Add to list of managed statics.
-      Next = StaticList;
-      StaticList = this;
     }
   } else {
-    assert(!Ptr && !DeleterFn && !Next &&
-           "Partially initialized ManagedStatic!?");
+    assert(!Ptr && "Partially initialized ManagedStatic!?");
     Ptr = Creator();
-    DeleterFn = Deleter;
-
-    // Add to list of managed statics.
-    Next = StaticList;
-    StaticList = this;
   }
 }
-
-void ManagedStaticBase::destroy() const {
-  assert(DeleterFn && "ManagedStatic not initialized correctly!");
-  assert(StaticList == this &&
-         "Not destroyed in reverse order of construction?");
-  // Unlink from list.
-  StaticList = Next;
-  Next = nullptr;
-
-  // Destroy memory.
-  DeleterFn(Ptr);
-
-  // Cleanup.
-  Ptr = nullptr;
-  DeleterFn = nullptr;
-}
-
-/// llvm_shutdown - Deallocate and destroy all ManagedStatic variables.
-/// IMPORTANT: it's only safe to call llvm_shutdown() in single thread,
-/// without any other threads executing LLVM APIs.
-/// llvm_shutdown() should be the last use of LLVM APIs.
-void llvm::llvm_shutdown() {
-  while (StaticList)
-    StaticList->destroy();
-}

llvm/lib/Support/Parallel.cpp

 //===- llvm/Support/Parallel.cpp - Parallel algorithms --------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/Parallel.h"
 #include "llvm/Config/llvm-config.h"
+#include "llvm/Support/FastShutdown.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Threading.h"
 
 #include <atomic>
 #include <future>
 #include <stack>
 #include <thread>
 #include <vector>
~ThreadPoolExecutor() override {
     std::thread::id CurrentThreadId = std::this_thread::get_id();
     for (std::thread &T : Threads)
       if (T.get_id() == CurrentThreadId)
         T.detach();
       else
         T.join();
   }
 
-  struct Creator {
-    static void *call() { return new ThreadPoolExecutor(strategy); }
-  };
-  struct Deleter {
-    static void call(void *Ptr) { ((ThreadPoolExecutor *)Ptr)->stop(); }
-  };
-
   void add(std::function<void()> F) override {
     {
       std::lock_guard<std::mutex> Lock(Mutex);
       WorkStack.push(std::move(F));
     }
     Cond.notify_one();
   }
 
private:
   std::atomic<bool> Stop{false};
   std::stack<std::function<void()>> WorkStack;
   std::mutex Mutex;
   std::condition_variable Cond;
   std::promise<void> ThreadsCreated;
   std::vector<std::thread> Threads;
 };
 
-Executor *Executor::getDefaultExecutor() {
-  // The ManagedStatic enables the ThreadPoolExecutor to be stopped via
-  // llvm_shutdown() which allows a "clean" fast exit, e.g. via _exit(). This
-  // stops the thread pool and waits for any worker thread creation to complete
-  // but does not wait for the threads to finish. The wait for worker thread
-  // creation to complete is important as it prevents intermittent crashes on
-  // Windows due to a race condition between thread creation and process exit.
-  //
-  // The ThreadPoolExecutor will only be destroyed when the static unique_ptr to
-  // it is destroyed, i.e. in a normal full exit. The ThreadPoolExecutor
-  // destructor ensures it has been stopped and waits for worker threads to
-  // finish. The wait is important as it prevents intermittent crashes on
-  // Windows when the process is doing a full exit.
-  //
-  // The Windows crashes appear to only occur with the MSVC static runtimes and
-  // are more frequent with the debug static runtime.
-  //
-  // This also prevents intermittent deadlocks on exit with the MinGW runtime.
+static ManagedStatic<ThreadPoolExecutor> DefaultExecutor;
+
+Executor *Executor::getDefaultExecutor() { return &*DefaultExecutor; }
 
-  static ManagedStatic<ThreadPoolExecutor, ThreadPoolExecutor::Creator,
-                       ThreadPoolExecutor::Deleter>
-      ManagedExec;
-  static std::unique_ptr<ThreadPoolExecutor> Exec(&(*ManagedExec));
-  return Exec.get();
-}
 } // namespace
 
 static std::atomic<int> TaskGroupInstances;
 
 // Latch::sync() called by the dtor may cause one thread to block. If is a dead
 // lock if all threads in the default executor are blocked. To prevent the dead
 // lock, only allow the first TaskGroup to run tasks parallelly. In the scenario
 // of nested parallel_for_each(), only the outermost one runs parallelly.
void TaskGroup::spawn(std::function<void()> F) {
   }
 }
 
 } // namespace detail
 } // namespace parallel
 } // namespace llvm
 #endif // LLVM_ENABLE_THREADS
 
+void llvm::fast_shutdown_parallel() {
+#if LLVM_ENABLE_THREADS
+  // Stop the executor, but only if it has been started.
+  //
+  // This allows a "clean" fast exit, via llvm_fast_shutdown() and e.g. _exit().
+  // This stops the thread pool and waits for any worker thread creation to
+  // complete but does not wait for the threads to finish. The wait for worker
+  // thread creation to complete is important as it prevents intermittent
+  // crashes on Windows due to a race condition between thread creation and
+  // process exit.
+  //
+  // The ThreadPoolExecutor will only be destroyed when the static unique_ptr to
+  // it is destroyed, i.e. in a normal full exit. The ThreadPoolExecutor
+  // destructor ensures it has been stopped and waits for worker threads to
+  // finish. The wait is important as it prevents intermittent crashes on
+  // Windows when the process is doing a full exit.
+  //
+  // The Windows crashes appear to only occur with the MSVC static runtimes and
+  // are more frequent with the debug static runtime.
+  //
+  // This also prevents intermittent deadlocks on exit with the MinGW runtime.
+  if (auto *Executor = parallel::detail::DefaultExecutor.peek())
+    Executor->stop();
+#endif
+}
+
 void llvm::parallelForEachN(size_t Begin, size_t End,
                             llvm::function_ref<void(size_t)> Fn) {
   // If we have zero or one items, then do not incur the overhead of spinning up
   // a task group.  They are surprisingly expensive, and because they do not
   // support nested parallelism, a single entry task group can block parallel
   // execution underneath them.
 #if LLVM_ENABLE_THREADS
   auto NumItems = End - Begin;

llvm/lib/Support/Statistic.cpp

 #include "llvm/ADT/Statistic.h"
 
 #include "DebugOptions.h"
 
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/Debug.h"
+#include "llvm/Support/FastShutdown.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/YAMLTraits.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
static cl::opt<bool, true> registerEnableStats{
       cl::location(EnableStats), cl::Hidden};
   static cl::opt<bool, true> registerStatsAsJson{
       "stats-json", cl::desc("Display statistics as json data"),
       cl::location(StatsAsJSON), cl::Hidden};
 }
 
 namespace {
 /// This class is used in a ManagedStatic so that it is created on demand (when
-/// the first statistic is bumped) and destroyed only when llvm_shutdown is
-/// called. We print statistics from the destructor.
+/// the first statistic is bumped) and destroyed only when ManagedStatics are
+/// destroyed. We print statistics from the destructor.
 /// This class is also used to look up statistic values from applications that
 /// use LLVM.
 class StatisticInfo {
   std::vector<TrackingStatistic *> Stats;
 
   friend void llvm::PrintStatistics();
   friend void llvm::PrintStatistics(raw_ostream &OS);
   friend void llvm::PrintStatisticsJSON(raw_ostream &OS);

 static ManagedStatic<StatisticInfo> StatInfo;
 static ManagedStatic<sys::SmartMutex<true> > StatLock;
 
 /// RegisterStatistic - The first time a statistic is bumped, this method is
 /// called.
 void TrackingStatistic::RegisterStatistic() {
   // If stats are enabled, inform StatInfo that this statistic should be
   // printed.
-  // llvm_shutdown calls destructors while holding the ManagedStatic mutex.
+  // ManagedStatic destructors are called while holding the ManagedStatic mutex.
   // These destructors end up calling PrintStatistics, which takes StatLock.
   // Since dereferencing StatInfo and StatLock can require taking the
   // ManagedStatic mutex, doing so with StatLock held would lead to a lock
   // order inversion. To avoid that, we dereference the ManagedStatics first,
   // and only take StatLock afterwards.
   if (!Initialized.load(std::memory_order_relaxed)) {
     sys::SmartMutex<true> &Lock = *StatLock;
     StatisticInfo &SI = *StatInfo;
const std::vector<std::pair<StringRef, unsigned>> llvm::GetStatistics() {
   for (const auto &Stat : StatInfo->statistics())
     ReturnStats.emplace_back(Stat->getName(), Stat->getValue());
   return ReturnStats;
 }
 
 void llvm::ResetStatistics() {
   StatInfo->reset();
 }
+
+void llvm::fast_shutdown_statistics() {
+  if (StatInfo.peek()) {
+    if (EnableStats || PrintOnExit)
+      PrintStatistics();
+  }
+}

llvm/lib/Support/Unix/DynamicLibrary.inc

 
 DynamicLibrary::HandleSet::~HandleSet() {
   // Close the libraries in reverse order.
   for (void *Handle : llvm::reverse(Handles))
     ::dlclose(Handle);
   if (Process)
     ::dlclose(Process);
 
-  // llvm_shutdown called, Return to default
+  // Global destructors run, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err) {
   void *Handle = ::dlopen(File, RTLD_LAZY|RTLD_GLOBAL);
   if (!Handle) {
     if (Err) *Err = ::dlerror();
     return &DynamicLibrary::Invalid;

llvm/lib/Support/Unix/Signals.inc

 //===----------------------------------------------------------------------===//
 //
 // This file is extremely careful to only do signal-safe things while in a
 // signal handler. In particular, memory allocation and acquiring a mutex
 // while in a signal handler should never occur. ManagedStatic isn't usable from
 // a signal handler for 2 reasons:
 //
 //  1. Creating a new one allocates.
-//  2. The signal handler could fire while llvm_shutdown is being processed, in
-//     which case the ManagedStatic is in an unknown state because it could
+//  2. The signal handler could fire while ManagedStatics are being destroyed,
+//     in which case the ManagedStatic is in an unknown state because it could
 //     already have been destroyed, or be in the process of being destroyed.
 //
 // Modifying the behavior of the signal handlers (such as registering new ones)
 // can acquire a mutex, but all this guarantees is that the signal handler
 // behavior is only modified by one thread at a time. A signal handler can still
 // fire while this occurs!
 //
 // Adding work to a signal handler requires lock-freedom (and assume atomics are
static void removeAllFiles(std::atomic<FileToRemoveList *> &Head) {
 
     // We're done removing files, cleanup can safely proceed.
     Head.exchange(OldHead);
   }
 };
 static std::atomic<FileToRemoveList *> FilesToRemove = ATOMIC_VAR_INIT(nullptr);
 
 /// Clean up the list in a signal-friendly manner.
-/// Recall that signals can fire during llvm_shutdown. If this occurs we should
-/// either clean something up or nothing at all, but we shouldn't crash!
+/// Recall that signals can fire while ManagedStatic destructors are run. If
+/// this occurs we should either clean something up or nothing at all, but we
+/// shouldn't crash!
 struct FilesToRemoveCleanup {
   // Not signal-safe.
   ~FilesToRemoveCleanup() {
     FileToRemoveList *Head = FilesToRemove.exchange(nullptr);
     if (Head)
       delete Head;
   }
 };

llvm/lib/Support/Windows/DynamicLibrary.inc

 
 
 DynamicLibrary::HandleSet::~HandleSet() {
   for (void *Handle : llvm::reverse(Handles))
     FreeLibrary(HMODULE(Handle));
 
   // 'Process' should not be released on Windows.
   assert((!Process || Process==this) && "Bad Handle");
-  // llvm_shutdown called, Return to default
+  // Global destructors run, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err) {
   // Create the instance and return it to be the *Process* handle
   // simillar to dlopen(NULL, RTLD_LAZY|RTLD_GLOBAL)
   if (!File)
     return &(*OpenedHandles);

llvm/tools/gold/gold-plugin.cpp

static ld_plugin_status allSymbolsReadHook() {
   std::vector<std::pair<SmallString<128>, bool>> Files = runLTO();
 
   if (options::TheOutputType == options::OT_DISABLE ||
       options::TheOutputType == options::OT_BC_ONLY ||
       options::TheOutputType == options::OT_ASM_ONLY)
     return LDPS_OK;
 
   if (options::thinlto_index_only) {
-    llvm_shutdown();
     cleanup_hook();
     exit(0);
   }
 
   for (const auto &F : Files)
     if (!F.first.empty())
       recordFile(std::string(F.first.str()), F.second);
 
   if (!options::extra_library_path.empty() &&
       set_extra_library_path(options::extra_library_path.c_str()) != LDPS_OK)
     message(LDPL_FATAL, "Unable to set the extra library path.");
 
   return LDPS_OK;
 }
 
 static ld_plugin_status all_symbols_read_hook(void) {
   ld_plugin_status Ret = allSymbolsReadHook();
-  llvm_shutdown();
 
   if (options::TheOutputType == options::OT_BC_ONLY ||
       options::TheOutputType == options::OT_ASM_ONLY ||
       options::TheOutputType == options::OT_DISABLE) {
     if (options::TheOutputType == options::OT_DISABLE) {
       // Remove the output file here since ld.bfd creates the output file
       // early.
       std::error_code EC = sys::fs::remove(output_name);

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

static void doLookup(GsymReader &Gsym, uint64_t Addr, raw_ostream &OS) {
   if (Verbose)
     OS << "\n";
 }
 
 int main(int argc, char const *argv[]) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   llvm::InitializeAllTargets();
 
   const char *Overview =
       "A tool for dumping, searching and creating GSYM files.\n\n"
       "Specify one or more GSYM paths as arguments to dump all of the "
       "information in each GSYM file.\n"
       "Specify a single GSYM file along with one or more --lookup options to "

llvm/unittests/ExecutionEngine/ExecutionEngineTest.cpp

 #include "llvm/Support/ManagedStatic.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 
 namespace {
 
 class ExecutionEngineTest : public testing::Test {
-private:
-  llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
-
 protected:
   ExecutionEngineTest() {
     auto Owner = std::make_unique<Module>("<main>", Context);
     M = Owner.get();
     Engine.reset(EngineBuilder(std::move(Owner)).setErrorStr(&Error).create());
   }
 
   void SetUp() override {

llvm/unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp

 
 static const char *OverloadTestA() { return "OverloadCall"; }
 
 std::string StdString(const char *Ptr) { return Ptr ? Ptr : ""; }
 
 TEST(DynamicLibrary, Overload) {
   {
     std::string Err;
-    llvm_shutdown_obj Shutdown;
     DynamicLibrary DL =
         DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     GetString GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
     EXPECT_NE(GS, nullptr);
     EXPECT_NE(GS, &TestA);
TEST(DynamicLibrary, Overload) {
 
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
     EXPECT_NE(GS, nullptr);
     EXPECT_EQ(GS, &OverloadTestA);
     EXPECT_EQ(StdString(GS()), "OverloadCall");
   }
   EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
                   "TestA")) == nullptr);
-
-  // Check serach ordering is reset to default after call to llvm_shutdown
-  EXPECT_EQ(DynamicLibrary::SearchOrder, DynamicLibrary::SO_Linker);
 }
 
 TEST(DynamicLibrary, Shutdown) {
   std::string A("PipSqueak"), B, C("SecondLib");
   std::vector<std::string> Order;
   {
     std::string Err;
-    llvm_shutdown_obj Shutdown;
     DynamicLibrary DL =
         DynamicLibrary::getPermanentLibrary(LibPath(A).c_str(), &Err);
     EXPECT_TRUE(DL.isValid());
     EXPECT_TRUE(Err.empty());
 
     SetStrings SS_0 = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
     EXPECT_NE(SS_0, nullptr);

llvm/utils/KillTheDoctor/KillTheDoctor.cpp

static StringRef ExceptionCodeToString(DWORD ExceptionCode) {
   default: return "<unknown>";
   }
 }
 
 int main(int argc, char **argv) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv[0]);
   PrettyStackTraceProgram X(argc, argv);
-  llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   ToolName = argv[0];
 
   cl::ParseCommandLineOptions(argc, argv, "Dr. Watson Assassin.\n");
   if (ProgramToRun.size() == 0) {
     cl::PrintHelpMessage();
     return -1;
   }

mlir/tools/mlir-vulkan-runner/mlir-vulkan-runner.cpp

static LogicalResult runMLIRPasses(ModuleOp module) {
   passManager.addPass(createMemRefToLLVMPass());
   passManager.addPass(createConvertFuncToLLVMPass(llvmOptions));
   passManager.addPass(createReconcileUnrealizedCastsPass());
   passManager.addPass(createConvertVulkanLaunchFuncToVulkanCallsPass());
   return passManager.run(module);
 }
 
 int main(int argc, char **argv) {
-  llvm::llvm_shutdown_obj x;
   registerPassManagerCLOptions();
 
   llvm::InitLLVM y(argc, argv);
   llvm::InitializeNativeTarget();
   llvm::InitializeNativeTargetAsmPrinter();
 
   mlir::JitRunnerConfig jitRunnerConfig;
   jitRunnerConfig.mlirTransformer = runMLIRPasses;

polly/lib/External/isl/interface/extract_interface.cc

int main(int argc, char *argv[])
   Diags.getClient()->BeginSourceFile(LO, &PP);
   ParseAST(*sema);
   Diags.getClient()->EndSourceFile();
 
   generate(consumer, Clang->getSourceManager());
 
   delete sema;
   delete Clang;
-  llvm::llvm_shutdown();
 
   if (Diags.hasErrorOccurred())
     return EXIT_FAILURE;
   return EXIT_SUCCESS;
 }