1 files changed, 72 insertions, 29 deletions

diff --git a/contrib/llvm-project/llvm/lib/Support/DynamicLibrary.cpp b/contrib/llvm-project/llvm/lib/Support/DynamicLibrary.cpp
index 7b9d7abe7545..531c035ab926 100644
--- a/contrib/llvm-project/llvm/lib/Support/DynamicLibrary.cpp
+++ b/contrib/llvm-project/llvm/lib/Support/DynamicLibrary.cpp
@@ -15,7 +15,6 @@
 #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>
 
@@ -42,13 +41,16 @@ public:
     return Handle == Process || Find(Handle) != Handles.end();
   }
 
-  bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true) {
+  bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true,
+                  bool AllowDuplicates = false) {
 #ifdef _WIN32
     assert((Handle == this ? IsProcess : !IsProcess) && "Bad Handle.");
 #endif
+    assert((!AllowDuplicates || !CanClose) &&
+           "CanClose must be false if AllowDuplicates is true.");
 
     if (LLVM_LIKELY(!IsProcess)) {
-      if (Find(Handle) != Handles.end()) {
+      if (!AllowDuplicates && Find(Handle) != Handles.end()) {
         if (CanClose)
           DLClose(Handle);
         return false;
@@ -68,6 +70,14 @@ public:
     return true;
   }
 
+  void CloseLibrary(void *Handle) {
+    DLClose(Handle);
+    HandleList::iterator it = Find(Handle);
+    if (it != Handles.end()) {
+      Handles.erase(it);
+    }
+  }
+
   void *LibLookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
     if (Order & SO_LoadOrder) {
       for (void *Handle : Handles) {
@@ -107,12 +117,23 @@ public:
 };
 
 namespace {
-// Collection of symbol name/value pairs to be searched prior to any libraries.
-static llvm::ManagedStatic<llvm::StringMap<void *>> ExplicitSymbols;
-// Collection of known library handles.
-static llvm::ManagedStatic<DynamicLibrary::HandleSet> OpenedHandles;
-// Lock for ExplicitSymbols and OpenedHandles.
-static llvm::ManagedStatic<llvm::sys::SmartMutex<true>> SymbolsMutex;
+
+struct Globals {
+  // Collection of symbol name/value pairs to be searched prior to any
+  // libraries.
+  llvm::StringMap<void *> ExplicitSymbols;
+  // Collections of known library handles.
+  DynamicLibrary::HandleSet OpenedHandles;
+  DynamicLibrary::HandleSet OpenedTemporaryHandles;
+  // Lock for ExplicitSymbols, OpenedHandles, and OpenedTemporaryHandles.
+  llvm::sys::SmartMutex<true> SymbolsMutex;
+};
+
+Globals &getGlobals() {
+  static Globals G;
+  return G;
+}
+
 } // namespace
 
 #ifdef _WIN32
@@ -136,20 +157,18 @@ void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
 } // 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);
@@ -157,14 +176,39 @@ DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
 
 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);
 }
 
+DynamicLibrary DynamicLibrary::getLibrary(const char *FileName,
+                                          std::string *Err) {
+  assert(FileName && "Use getPermanentLibrary() for opening process handle");
+  void *Handle = HandleSet::DLOpen(FileName, Err);
+  if (Handle != &Invalid) {
+    auto &G = getGlobals();
+    SmartScopedLock<true> Lock(G.SymbolsMutex);
+    G.OpenedTemporaryHandles.AddLibrary(Handle, /*IsProcess*/ false,
+                                        /*CanClose*/ false,
+                                        /*AllowDuplicates*/ true);
+  }
+  return DynamicLibrary(Handle);
+}
+
+void DynamicLibrary::closeLibrary(DynamicLibrary &Lib) {
+  auto &G = getGlobals();
+  SmartScopedLock<true> Lock(G.SymbolsMutex);
+  if (Lib.isValid()) {
+    G.OpenedTemporaryHandles.CloseLibrary(Lib.Data);
+    Lib.Data = &Invalid;
+  }
+}
+
 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
   if (!isValid())
     return nullptr;
@@ -173,21 +217,20 @@ void *DynamicLibrary::getAddressOfSymbol(const char *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())
+      return i->second;
 
     // 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 Ptr;
+    if (void *Ptr = G.OpenedTemporaryHandles.Lookup(SymbolName, SearchOrder))
+      return Ptr;
   }
 
   return llvm::SearchForAddressOfSpecialSymbol(SymbolName);