Remove ManagedStatic and deprecate llvm_shutdown

[deadalnix]

Make sure you wait for 1 release cycle before actually removing the function.

[nhaehnle]

Rebase

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.
-
 .. _llvmcontext:
 
 Achieving Isolation with ``LLVMContext``
 ----------------------------------------
 
 ``LLVMContext`` is an opaque class in the LLVM API which clients can use to
 operate multiple, isolated instances of LLVM concurrently within the same
 address space.  For instance, in a hypothetical compile-server, the compilation

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 function has become a no-op");
 
 /*===-- Error handling ----------------------------------------------------===*/
 
 char *LLVMCreateMessage(const char *Message);
 void LLVMDisposeMessage(char *Message);
 
 /**
  * @defgroup LLVMCCoreContext Contexts

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 used to define the ManagedStatic class. It will be removed.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_MANAGEDSTATIC_H
 #define LLVM_SUPPORT_MANAGEDSTATIC_H
 
 #include <atomic>
 #include <cstddef>
 
 namespace llvm {
 
-/// object_creator - Helper method for ManagedStatic.
-template <class C> struct object_creator {
-  static void *call() { return new C(); }
-};
-
-/// object_deleter - Helper method for ManagedStatic.
-///
-template <typename T> struct object_deleter {
-  static void call(void *Ptr) { delete (T *)Ptr; }
-};
-template <typename T, size_t N> struct object_deleter<T[N]> {
-  static void call(void *Ptr) { delete[](T *)Ptr; }
-};
-
-// ManagedStatic must be initialized to zero, and it must *not* have a dynamic
-// initializer because managed statics are often created while running other
-// dynamic initializers. In standard C++11, the best way to accomplish this is
-// with a constexpr default constructor. However, different versions of the
-// Visual C++ compiler have had bugs where, even though the constructor may be
-// constexpr, a dynamic initializer may be emitted depending on optimization
-// settings. For the affected versions of MSVC, use the old linker
-// initialization pattern of not providing a constructor and leaving the fields
-// uninitialized. See http://llvm.org/PR41367 for details.
-#if !defined(_MSC_VER) || (_MSC_VER >= 1925) || defined(__clang__)
-#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;
-
-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.
-///
-template <class C, class Creator = object_creator<C>,
-          class Deleter = object_deleter<C>>
-class [[deprecated("ManagedStatic is deprecated and will be removed; use "
-                   "function scope static variables in a getter function "
-                   "instead")]] ManagedStatic : public ManagedStaticBase {
-public:
-  // Accessors.
-  C &operator*() {
-    void *Tmp = Ptr.load(std::memory_order_acquire);
-    if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
-
-    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
-  }
-
-  C *operator->() { return &**this; }
-
-  const C &operator*() const {
-    void *Tmp = Ptr.load(std::memory_order_acquire);
-    if (!Tmp)
-      RegisterManagedStatic(Creator::call, Deleter::call);
-
-    return *static_cast<C *>(Ptr.load(std::memory_order_relaxed));
-  }
-
-  const C *operator->() const { return &**this; }
-
-  // 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();
-
-/// 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(); }
-};
+[[deprecated("llvm_shutdown is a no-op; shutdown now happens by "
+             "default")]] static inline void
+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

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/PassRegistry.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FileSystem.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Threading.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdlib>
 #include <cstring>
 #include <system_error>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "ir"
 
 void llvm::initializeCore(PassRegistry &Registry) {
   initializeDominatorTreeWrapperPassPass(Registry);
   initializePrintModulePassWrapperPass(Registry);
   initializePrintFunctionPassWrapperPass(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/Support/CMakeLists.txt

add_llvm_component_library(LLVMSupport
   ItaniumManglingCanonicalizer.cpp
   JSON.cpp
   KnownBits.cpp
   LEB128.cpp
   LineIterator.cpp
   Locale.cpp
   LockFileManager.cpp
   LowLevelType.cpp
-  ManagedStatic.cpp
   MathExtras.cpp
   MemAlloc.cpp
   MemoryBuffer.cpp
   MemoryBufferRef.cpp
   MD5.cpp
   MSP430Attributes.cpp
   MSP430AttributeParser.cpp
   NativeFormatting.cpp

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().
-//
-//===----------------------------------------------------------------------===//
-
-#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 {
-  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!?");
-    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/unittests/Support/CMakeLists.txt

add_llvm_unittest(SupportTests
   JSONTest.cpp
   KnownBitsTest.cpp
   LEB128Test.cpp
   LinearPolyBaseTest.cpp
   LineIteratorTest.cpp
   LockFileManagerTest.cpp
   MatchersTest.cpp
   MD5Test.cpp
-  ManagedStatic.cpp
   MathExtrasTest.cpp
   MemoryBufferRefTest.cpp
   MemoryBufferTest.cpp
   MemoryTest.cpp
   NativeFormatTests.cpp
   OptimizedStructLayoutTest.cpp
   ParallelTest.cpp
   Path.cpp
if( CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.14 )
     # Since VS2017 15.8, the following snippet: Failed<CustomSubError>()
     # generates a warning:
     # \svn\llvm\utils\unittest\googlemock\include\gmock\gmock-matchers.h(186):
     #   warning C5046: 'testing::MatcherInterface<T>::~MatcherInterface': Symbol involving type with internal linkage not defined
     set_source_files_properties(ErrorTest.cpp PROPERTIES COMPILE_FLAGS -wd5046)
   endif()
 endif()
 
-# ManagedStatic.cpp uses <pthread>.
 target_link_libraries(SupportTests PRIVATE LLVMTestingSupport ${LLVM_PTHREAD_LIB})
 
 if(NOT LLVM_INTEGRATED_CRT_ALLOC)
   # The test doesn't pass when using a custom allocator, PR47881.
   add_subdirectory(DynamicLibrary)
 endif()
 
 add_subdirectory(CommandLineInit)

llvm/unittests/Support/ManagedStatic.cpp

-//===- llvm/unittest/Support/ManagedStatic.cpp - ManagedStatic tests ------===//
-//
-// 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/Allocator.h"
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/Config/config.h"
-#ifdef HAVE_PTHREAD_H
-#include <pthread.h>
-#endif
-
-#include "gtest/gtest.h"
-
-using namespace llvm;
-
-namespace {
-
-#if LLVM_ENABLE_THREADS != 0 && defined(HAVE_PTHREAD_H) && \
-  !__has_feature(memory_sanitizer)
-namespace test1 {
-  llvm::ManagedStatic<int> ms;
-  void *helper(void*) {
-    *ms;
-    return nullptr;
-  }
-
-  // Valgrind's leak checker complains glibc's stack allocation.
-  // To appease valgrind, we provide our own stack for each thread.
-  void *allocate_stack(pthread_attr_t &a, size_t n = 65536) {
-    void *stack = safe_malloc(n);
-    pthread_attr_init(&a);
-#if defined(__linux__)
-    pthread_attr_setstack(&a, stack, n);
-#endif
-    return stack;
-  }
-}
-
-TEST(Initialize, MultipleThreads) {
-  // Run this test under tsan: http://code.google.com/p/data-race-test/
-
-  pthread_attr_t a1, a2;
-  void *p1 = test1::allocate_stack(a1);
-  void *p2 = test1::allocate_stack(a2);
-
-  pthread_t t1, t2;
-  pthread_create(&t1, &a1, test1::helper, nullptr);
-  pthread_create(&t2, &a2, test1::helper, nullptr);
-  pthread_join(t1, nullptr);
-  pthread_join(t2, nullptr);
-  free(p1);
-  free(p2);
-}
-#endif
-
-namespace NestedStatics {
-static ManagedStatic<int> Ms1;
-struct Nest {
-  Nest() {
-    ++(*Ms1);
-  }
-
-  ~Nest() {
-    assert(Ms1.isConstructed());
-    ++(*Ms1);
-  }
-};
-static ManagedStatic<Nest> Ms2;
-
-TEST(ManagedStaticTest, NestedStatics) {
-  EXPECT_FALSE(Ms1.isConstructed());
-  EXPECT_FALSE(Ms2.isConstructed());
-
-  *Ms2;
-  EXPECT_TRUE(Ms1.isConstructed());
-  EXPECT_TRUE(Ms2.isConstructed());
-}
-} // namespace NestedStatics
-
-namespace CustomCreatorDeletor {
-struct CustomCreate {
-  static void *call() {
-    void *Mem = safe_malloc(sizeof(int));
-    *((int *)Mem) = 42;
-    return Mem;
-  }
-};
-struct CustomDelete {
-  static void call(void *P) { std::free(P); }
-};
-static ManagedStatic<int, CustomCreate, CustomDelete> Custom;
-TEST(ManagedStaticTest, CustomCreatorDeletor) {
-  EXPECT_EQ(42, *Custom);
-}
-} // namespace CustomCreatorDeletor
-
-} // anonymous namespace

llvm/utils/gn/secondary/llvm/lib/Support/BUILD.gn

sources = [
     "LEB128.cpp",
     "LineIterator.cpp",
     "Locale.cpp",
     "LockFileManager.cpp",
     "LowLevelType.cpp",
     "MD5.cpp",
     "MSP430AttributeParser.cpp",
     "MSP430Attributes.cpp",
-    "ManagedStatic.cpp",
     "MathExtras.cpp",
     "MemAlloc.cpp",
     "MemoryBuffer.cpp",
     "MemoryBufferRef.cpp",
     "NativeFormatting.cpp",
     "OptimizedStructLayout.cpp",
     "Optional.cpp",
     "Parallel.cpp",

llvm/utils/gn/secondary/llvm/unittests/Support/BUILD.gn

sources = [
     "ItaniumManglingCanonicalizerTest.cpp",
     "JSONTest.cpp",
     "KnownBitsTest.cpp",
     "LEB128Test.cpp",
     "LineIteratorTest.cpp",
     "LinearPolyBaseTest.cpp",
     "LockFileManagerTest.cpp",
     "MD5Test.cpp",
-    "ManagedStatic.cpp",
     "MatchersTest.cpp",
     "MathExtrasTest.cpp",
     "MemoryBufferRefTest.cpp",
     "MemoryBufferTest.cpp",
     "MemoryTest.cpp",
     "NativeFormatTests.cpp",
     "OptimizedStructLayoutTest.cpp",
     "ParallelTest.cpp",