ManagedStatic: remove from DynamicLibrary

[nhaehnle]

Rebase

[efriedma]

LGTM

[Meinersbur]

I am responsible for one of the buildbots that failed (https://lab.llvm.org/buildbot/#/builders/172). If you don't have access to a Windows machine to reproduce the problem, I could help.

[nhaehnle]

In D129127#3696861, @Meinersbur wrote:

I am responsible for one of the buildbots that failed (https://lab.llvm.org/buildbot/#/builders/172). If you don't have access to a Windows machine to reproduce the problem, I could help.

@Meinersbur Thanks, I'd appreciate it. It looked easy enough to fix, but if you could give it a pre-test then for your convenience I put it here: https://github.com/nhaehnle/llvm-project/tree/managedstatic-dynamiclibrary

git fetch [e-mail]:nhaehnle/llvm-project.git managedstatic-dynamiclibrary && git switch -d FETCH_HEAD

llvm/lib/Support/DynamicLibrary.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm-c/Support.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
-#include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::sys;
 
 // All methods for HandleSet should be used holding SymbolsMutex.
 class DynamicLibrary::HandleSet {
if (Process) {
           return Ptr;
       }
     }
     return nullptr;
   }
 };
 
 namespace {
-// Collection of symbol name/value pairs to be searched prior to any libraries.
-static llvm::ManagedStatic<llvm::StringMap<void *>> ExplicitSymbols;
+
+struct Globals {
+  // Collection of symbol name/value pairs to be searched prior to any
+  // libraries.
+  llvm::StringMap<void *> ExplicitSymbols;
   // Collection of known library handles.
-static llvm::ManagedStatic<DynamicLibrary::HandleSet> OpenedHandles;
+  DynamicLibrary::HandleSet OpenedHandles;
   // Lock for ExplicitSymbols and OpenedHandles.
-static llvm::ManagedStatic<llvm::sys::SmartMutex<true>> SymbolsMutex;
+  llvm::sys::SmartMutex<true> SymbolsMutex;
+};
+
+Globals &getGlobals() {
+  static Globals G;
+  return G;
+}
+
 } // namespace
 
 #ifdef _WIN32
 
 #include "Windows/DynamicLibrary.inc"
 
 #else
 
 #include "Unix/DynamicLibrary.inc"
 
 #endif
 
 char DynamicLibrary::Invalid;
 DynamicLibrary::SearchOrdering DynamicLibrary::SearchOrder =
     DynamicLibrary::SO_Linker;
 
 namespace llvm {
 void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
   return DoSearch(SymbolName); // DynamicLibrary.inc
 }
 } // namespace llvm
 
 void DynamicLibrary::AddSymbol(StringRef SymbolName, void *SymbolValue) {
-  SmartScopedLock<true> Lock(*SymbolsMutex);
-  (*ExplicitSymbols)[SymbolName] = SymbolValue;
+  auto &G = getGlobals();
+  SmartScopedLock<true> Lock(G.SymbolsMutex);
+  G.ExplicitSymbols[SymbolName] = SymbolValue;
 }
 
 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
                                                    std::string *Err) {
-  // Force OpenedHandles to be added into the ManagedStatic list before any
-  // ManagedStatic can be added from static constructors in HandleSet::DLOpen.
-  HandleSet& HS = *OpenedHandles;
-
+  auto &G = getGlobals();
   void *Handle = HandleSet::DLOpen(FileName, Err);
   if (Handle != &Invalid) {
-    SmartScopedLock<true> Lock(*SymbolsMutex);
-    HS.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
+    SmartScopedLock<true> Lock(G.SymbolsMutex);
+    G.OpenedHandles.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
   }
 
   return DynamicLibrary(Handle);
 }
 
 DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,
                                                    std::string *Err) {
-  SmartScopedLock<true> Lock(*SymbolsMutex);
+  auto &G = getGlobals();
+  SmartScopedLock<true> Lock(G.SymbolsMutex);
   // If we've already loaded this library, tell the caller.
-  if (!OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false))
+  if (!G.OpenedHandles.AddLibrary(Handle, /*IsProcess*/ false,
+                                  /*CanClose*/ false))
     *Err = "Library already loaded";
 
   return DynamicLibrary(Handle);
 }
 
 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
   if (!isValid())
     return nullptr;
   return HandleSet::DLSym(Data, SymbolName);
 }
 
 void *DynamicLibrary::SearchForAddressOfSymbol(const char *SymbolName) {
   {
-    SmartScopedLock<true> Lock(*SymbolsMutex);
+    auto &G = getGlobals();
+    SmartScopedLock<true> Lock(G.SymbolsMutex);
 
     // First check symbols added via AddSymbol().
-    if (ExplicitSymbols.isConstructed()) {
-      StringMap<void *>::iterator i = ExplicitSymbols->find(SymbolName);
+    StringMap<void *>::iterator i = G.ExplicitSymbols.find(SymbolName);
 
-      if (i != ExplicitSymbols->end())
-        return i->second;
-    }
+    if (i != G.ExplicitSymbols.end())
 
     // Now search the libraries.
-    if (OpenedHandles.isConstructed()) {
-      if (void *Ptr = OpenedHandles->Lookup(SymbolName, SearchOrder))
-        return Ptr;
-    }
-  }
+    if (void *Ptr = G.OpenedHandles.Lookup(SymbolName, SearchOrder))
 
   return llvm::SearchForAddressOfSpecialSymbol(SymbolName);
 }
 
 //===----------------------------------------------------------------------===//
 // C API.
 //===----------------------------------------------------------------------===//
 

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) {
     EXPECT_NE(GS, nullptr);
     EXPECT_NE(GS, &OverloadTestA);
 
     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);
-
-    SS_0(A, B);
-    EXPECT_EQ(B, "Local::Local(PipSqueak)");
-
-    TestOrder TO_0 = FuncPtr<TestOrder>(
-        DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
-    EXPECT_NE(TO_0, nullptr);
-
-    DynamicLibrary DL2 =
-        DynamicLibrary::getPermanentLibrary(LibPath(C).c_str(), &Err);
-    EXPECT_TRUE(DL2.isValid());
-    EXPECT_TRUE(Err.empty());
-
-    // Should find latest version of symbols in SecondLib
-    SetStrings SS_1 = FuncPtr<SetStrings>(
-        DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
-    EXPECT_NE(SS_1, nullptr);
-    EXPECT_NE(SS_0, SS_1);
-
-    TestOrder TO_1 = FuncPtr<TestOrder>(
-        DynamicLibrary::SearchForAddressOfSymbol("TestOrder"));
-    EXPECT_NE(TO_1, nullptr);
-    EXPECT_NE(TO_0, TO_1);
-
-    B.clear();
-    SS_1(C, B);
-    EXPECT_EQ(B, "Local::Local(SecondLib)");
-
-    TO_0(Order);
-    TO_1(Order);
-  }
-  EXPECT_EQ(A, "Global::~Global");
-  EXPECT_EQ(B, "Local::~Local");
-  EXPECT_EQ(FuncPtr<SetStrings>(
-                DynamicLibrary::SearchForAddressOfSymbol("SetStrings")),
-            nullptr);
-
-  // Test unload/destruction ordering
-  EXPECT_EQ(Order.size(), 2UL);
-  EXPECT_EQ(Order.front(), "SecondLib");
-  EXPECT_EQ(Order.back(), "PipSqueak");
 }
 
 #else
 
 TEST(DynamicLibrary, Unsupported) {
   std::string Err;
   DynamicLibrary DL =
       DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
   EXPECT_FALSE(DL.isValid());
   EXPECT_EQ(Err, "dlopen() not supported on this platform");
 }
 
 #endif