Remove uses of llvm_shutdown

[nhaehnle]

Summary

With the removal of ManagedStatic, llvm_shutdown will be removed as
well.

[nhaehnle]

Rebase

[Meinersbur]

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

590

This file is imported from the upstream project (https://repo.or.cz/isl.git/blob/295cf91923295ca694e9e4433a0b818150421bee:/interface/extract_interface.cc#l590) and this change will be lost when synchronizing with it. However, this file is also not used within LLVM. I recommend to just keep as-is.

[nhaehnle]

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

590

Thanks, will do.

[nhaehnle]

Address review comment

[efriedma]

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

590

I think you missed the other change in this file?

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 checkDiagErrors(Interp->getCompilerInstance());
 }

clang/unittests/Interpreter/ExceptionTests/InterpreterExceptionTest.cpp

 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/Version.h"
 #include "clang/Config/config.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm-c/Error.h"
 
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 using namespace clang;
 
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

 #if HAVE_LLVM > 0x0390
 #include "llvm/Bitcode/BitcodeReader.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
 #else
 #include "llvm/Bitcode/ReaderWriter.h"
 #endif
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/ToolOutputFile.h"
 #include "llvm/Config/llvm-config.h"
 
 #include <system_error>
 
 using namespace llvm;
 
 static cl::opt<std::string>
 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 =

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

 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "llvm/ADT/IntervalMap.h"
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WithColor.h"
 
 #include <cstdio>
 #include <thread>
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

 //===-- LogTest.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 "gmock/gmock.h"
 #include "gtest/gtest.h"
 
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/BitmaskEnum.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Threading.h"
 #include <thread>
 
 using namespace lldb;
 using namespace lldb_private;
 
 enum class TestChannel : Log::MaskType {
   FOO = Log::ChannelFlag<0>,

 // A test fixture which provides tests with a pre-registered channel.
 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();
   }
 };
 
 class TestLogHandler : public LogHandler {
 public:
   TestLogHandler() : m_messages(), m_stream(m_messages) {}
 
   void Emit(llvm::StringRef message) override { m_stream << message; }

 }
 
 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;
   auto log_handler_sp = std::make_shared<TestLogHandler>();
   EXPECT_TRUE(
       Log::EnableLogChannel(log_handler_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/examples/BrainF/BrainFDriver.cpp

 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Value.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstdlib>
 #include <fstream>
 #include <iostream>
 #include <memory>
 #include <string>
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

 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/Support/Casting.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <memory>
 #include <vector>
 
 using namespace llvm;
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/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/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/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/Support/InitLLVM.cpp

 //===-- InitLLVM.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/InitLLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SwapByteOrder.h"
 
 #ifdef _WIN32
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Windows/WindowsSupport.h"
 #endif
#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/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

 //===- Signals.cpp - Generic Unix Signals Implementation -----*- 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 some helpful functions for dealing with the possibility of
 // Unix signals occurring while your program is running.
 //
 //===----------------------------------------------------------------------===//
 //
 // 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
-//     already have been destroyed, or be in the process of being destroyed.
+// while in a signal handler should never occur.
 //
 // 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
 // always lock-free) because the signal handler could fire while new work is
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 global 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

 #include "llvm/LTO/LTO.h"
 #include "llvm/Object/Error.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CachePruning.h"
 #include "llvm/Support/Caching.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Host.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 #include <list>
 #include <map>
 #include <plugin-api.h>
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

 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELFObjectFile.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstring>
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

 //===- ExecutionEngineTest.cpp - Unit tests for ExecutionEngine -----------===//
 //
 // 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/ADT/STLExtras.h"
 #include "llvm/ExecutionEngine/Interpreter.h"
 #include "llvm/ExecutionEngine/RTDyldMemoryManager.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/DynamicLibrary.h"
-#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

 //===- llvm/unittest/Support/DynamicLibrary/DynamicLibraryTest.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/DynamicLibrary.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "gtest/gtest.h"
 
 #include "PipSqueak.h"
 
 using namespace llvm;
 using namespace llvm::sys;
 

 
 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

 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/WindowsError.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Support/type_traits.h"
 #include <algorithm>
 #include <cerrno>
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.nest<func::FuncOp>().addPass(LLVM::createRequestCWrappersPass());
   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

 #include <memory>
 #endif
 #ifdef HAVE_LLVM_OPTION_ARG_H
 #include <llvm/Option/Arg.h>
 #endif
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/Host.h>
-#include <llvm/Support/ManagedStatic.h>
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/ASTConsumer.h>
 #include <clang/Basic/Builtins.h>
 #include <clang/Basic/FileSystemOptions.h>
 #include <clang/Basic/FileManager.h>
 #include <clang/Basic/TargetOptions.h>
 #include <clang/Basic/TargetInfo.h>
 #include <clang/Basic/Version.h>
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;
 }