Extend DynamicLibrary class to be usable without loading permanently.

[marsupial]

Ping.

[marsupial]

Include PointerIntPair.h for modules build & resolved conflict.

[marsupial]

Use to std::pair instead of PointerIntPair, it's lighter for the temporary.

[marsupial]

Ping,

include/llvm/Support/DynamicLibrary.h

class DynamicLibrary {
     // We use this instead of NULL or a pointer-int pair because the OS library
     // might define 0 or 1 to be "special" handles, such as "search all".
     static char Invalid;
 
     // Opaque data used to interface with OS-specific dynamic library handling.
     void *Data;
 
   public:
-    explicit DynamicLibrary(void *data = &Invalid) : Data(data) {}
+    explicit DynamicLibrary(void *Handle = &Invalid) : Data(Handle) {}
+
+    /// @brief Load the library from Filename storing errors in ErrMsg.
+    DynamicLibrary(const char *Filename, std::string *ErrMsg = nullptr,
+                   bool RTLocal = false);
+
+    /// @brief Convenience function for using RTLocal without error reporting.
+    DynamicLibrary(const char *Filename, bool RTLocal)
+        : DynamicLibrary(Filename, nullptr, RTLocal) {}
+
+    DynamicLibrary(DynamicLibrary &&Other) : Data(Other.Data) {
+      Other.Data = &Invalid;
+    }
+
+    DynamicLibrary(const DynamicLibrary&) = delete;
+    ~DynamicLibrary();
 
     /// Returns true if the object refers to a valid library.
     bool isValid() const { return Data != &Invalid; }
 
+    /// Comparison operators
+    operator bool () const { return isValid(); }
+    bool operator == (const void *Handle) { return Data == Handle; }
+    bool operator != (const void *Handle) { return Data != Handle; }
+    bool operator < (const void *Handle) { return Data < Handle; }
+
     /// Searches through the library for the symbol \p symbolName. If it is
     /// 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);
+    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.
-    /// 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.
+    /// This returns a pointer to the DynamicLibrary instance on success and an
+    /// nullptr on failure . \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.
     /// @brief Open a dynamic library permanently.
     /// @param Filename The path to the library.
     /// @param ErrMsg Any error encountered will be stored here.
     /// @param RTLocal Open with RTLD_LOCAL flag on platforms supporting dlopen,
     /// otherwise ignored.
-    static DynamicLibrary getPermanentLibrary(const char *Filename,
+    static DynamicLibrary *getPermanentLibrary(const char *Filename,
                                                std::string *ErrMsg = nullptr,
                                                bool RTLocal = false);
 
     /// @brief Convenience function for using RTLocal without error reporting.
-    static DynamicLibrary getPermanentLibrary(const char *Filename,
+    static DynamicLibrary *getPermanentLibrary(const char *Filename,
                                                bool RTLocal) {
       return getPermanentLibrary(Filename, nullptr, RTLocal);
     }
 
     /// Registers an externally loaded library. The library will be unloaded
     /// when the program terminates.
     ///
     /// It is safe to call this function multiple times for the same library,
     /// though ownership is only taken if there was no error.
     ///
     /// \returns An empty \p DynamicLibrary if the library was already loaded.
-    static DynamicLibrary addPermanentLibrary(void *handle,
-                                              std::string *errMsg = nullptr);
+    static DynamicLibrary *addPermanentLibrary(void *Handle,
+                                               std::string *ErrMsg = nullptr);
 
     /// This function permanently loads the dynamic library at the given path.
     /// Use this instead of getPermanentLibrary() when you won't need to get
     /// symbols from the library itself.
     ///
     /// It is safe to call this function multiple times for the same library.
     static bool LoadLibraryPermanently(const char *Filename,
                                        std::string *ErrMsg = nullptr) {
-      return !getPermanentLibrary(Filename, ErrMsg).isValid();
+      return getPermanentLibrary(Filename, ErrMsg) != nullptr;
     }
 
     enum SearchOrdering {
       /// SO_Linker - Search as a call to dlsym(dlopen(NULL)) would when
       /// DynamicLibrary::getPermanentLibrary(NULL) has been called or
       /// search the list of explcitly loaded symbols if not.
       SO_Linker,
       /// SO_LoadedFirst - Search all loaded libraries then as SO_Linker would

lib/Support/DynamicLibrary.cpp

 //===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the operating system DynamicLibrary concept.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm-c/Support.h"
 #include "llvm/ADT/DenseSet.h"
-#include "llvm/ADT/iterator_range.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/Config/config.h"
 #include "llvm/Support/ManagedStatic.h"
 #include "llvm/Support/Mutex.h"
 #include <cstdio>
 #include <cstring>
 #include <vector>
 
 using namespace llvm;
 using namespace llvm::sys;
 
 // All methods for HandleSet should be used holding SymbolsMutex.
 class DynamicLibrary::HandleSet {
-  typedef std::vector<void *> HandleList;
+  typedef std::vector<DynamicLibrary> HandleList;
+  typedef PointerIntPair<DynamicLibrary *, 1, bool> ReturnTy;
   HandleList Handles;
-  void *Process;
+  DynamicLibrary Process;
 
 public:
   static void *DLOpen(const char *Filename, std::string *Err, bool Local);
   static void DLClose(void *Handle);
   static void *DLSym(void *Handle, const char *Symbol);
 
-  HandleSet() : Process(nullptr) {}
+  HandleSet() {}
   ~HandleSet();
 
   HandleList::iterator Find(void *Handle) {
     return std::find(Handles.begin(), Handles.end(), Handle);
   }
 
   bool Contains(void *Handle) {
-    return Handle == Process || Find(Handle) != Handles.end();
+    return Handle == Process.Data || Find(Handle) != Handles.end();
   }
 
-  bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true) {
+  ReturnTy AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true) {
+    assert(Handle != &DynamicLibrary::Invalid);
 #ifdef LLVM_ON_WIN32
     assert((Handle == this ? IsProcess : !IsProcess) && "Bad Handle.");
 #endif
 
     if (LLVM_LIKELY(!IsProcess)) {
-      if (Find(Handle) != Handles.end()) {
+      auto Itr = Find(Handle);
+      if (Itr != Handles.end()) {
         if (CanClose)
           DLClose(Handle);
-        return false;
-      }
-      Handles.push_back(Handle);
-    } else {
+        return ReturnTy(&(*Itr), false);
+      }
+      Handles.emplace_back(Handle);
+      return ReturnTy(&Handles.back(), true);
 #ifndef LLVM_ON_WIN32
-      if (Process) {
-        if (CanClose)
-          DLClose(Process);
-        if (Process == Handle)
-          return false;
-      }
+        DLClose(Process.Data);
+      if (Process.Data == Handle)
+        return ReturnTy(&Process, false);
 #endif
-      Process = Handle;
-    }
-    return true;
+    Process.Data = Handle;
+    return ReturnTy(&Process, false);
   }
 
   void *Lookup(const char *Symbol) {
     // Iterate in reverse, so newer libraries/symbols override older.
-    for (auto &&I = Handles.rbegin(), E = Handles.rend(); I != E; ++I) {
-      if (void *Ptr = DLSym(*I, Symbol))
+    for (auto I = Handles.rbegin(), E = Handles.rend(); I != E; ++I) {
+      if (void *Ptr = DLSym(I->Data, Symbol))
         return Ptr;
     }
     return nullptr;
   }
 
   void *Lookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
     if (!Process || Order == DynamicLibrary::SO_LoadedFirst) {
       if (void *Ptr = Lookup(Symbol))
         return Ptr;
     }
     if (Process) {
       // Use OS facilities to search the current binary and all loaded libs.
-      if (void *Ptr = DLSym(Process, Symbol))
+      if (void *Ptr = DLSym(Process.Data, Symbol))
         return Ptr;
 
       // Search any libs that might have been skipped because of RTLD_LOCAL.
       if (Order == DynamicLibrary::SO_LoadedLast) {
         if (void *Ptr = Lookup(Symbol))
           return Ptr;
       }
     }
DynamicLibrary::SearchOrdering DynamicLibrary::SearchOrder =
     DynamicLibrary::SO_Linker;
 
 namespace llvm {
 void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
   return DoSearch(SymbolName); // DynamicLibrary.inc
 }
 }
 
+DynamicLibrary::DynamicLibrary(const char *File, std::string *Err, bool RTLocal)
+    : Data(HandleSet::DLOpen(File, Err, RTLocal)) {}
+
+DynamicLibrary::~DynamicLibrary() {
+  if (isValid())
+    HandleSet::DLClose(Data);
+}
+
 void DynamicLibrary::AddSymbol(StringRef SymbolName, void *SymbolValue) {
   SmartScopedLock<true> Lock(*SymbolsMutex);
   (*ExplicitSymbols)[SymbolName] = SymbolValue;
 }
 
-DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
-                                                   std::string *Err, bool Lcl) {
+DynamicLibrary *DynamicLibrary::getPermanentLibrary(const char *FileName,
+                                                    std::string *Err, bool LC) {
   // Force OpenedHandles to be added into the ManagedStatic list before any
   // ManagedStatic can be added from static constructors in HandleSet::DLOpen.
   HandleSet& HS = *OpenedHandles;
 
-  void *Handle = HandleSet::DLOpen(FileName, Err, Lcl);
+  void *Handle = HandleSet::DLOpen(FileName, Err, LC);
   if (Handle != &Invalid) {
     SmartScopedLock<true> Lock(*SymbolsMutex);
-    HS.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
+    return HS.AddLibrary(Handle, /*IsProcess*/FileName == nullptr).getPointer();
   }
 
-  return DynamicLibrary(Handle);
+  return nullptr;
 }
 
-DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,
+DynamicLibrary *DynamicLibrary::addPermanentLibrary(void *Handle,
                                                     std::string *Err) {
   SmartScopedLock<true> Lock(*SymbolsMutex);
+  auto DL = OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false);
   // If we've already loaded this library, tell the caller.
-  if (!OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false))
+  if (!DL.getInt())
     *Err = "Library already loaded";
 
-  return DynamicLibrary(Handle);
+  return DL.getPointer();
 }
 
 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
   if (!isValid())
     return nullptr;
   return HandleSet::DLSym(Data, SymbolName);
 }
 

lib/Support/Unix/DynamicLibrary.inc

 //
 //===----------------------------------------------------------------------===//
 
 #if defined(HAVE_DLFCN_H) && defined(HAVE_DLOPEN)
 #include <dlfcn.h>
 
 DynamicLibrary::HandleSet::~HandleSet() {
   // Close the libraries in reverse order.
-  for (void *Handle : llvm::reverse_range(Handles))
-    ::dlclose(Handle);
-  if (Process)
-    ::dlclose(Process);
+  for (DynamicLibrary &DL : reverse_range(Handles)) {
+    assert(DL.Data != &DynamicLibrary::Invalid);
+    ::dlclose(DL.Data);
+    DL.Data = &DynamicLibrary::Invalid;
+  }
+  if (Process) {
+    ::dlclose(Process.Data);
+    Process.Data = &DynamicLibrary::Invalid;
+  }
 
   // llvm_shutdown called, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err,
                                         bool Local) {
   void *Handle = ::dlopen(File, RTLD_LAZY | (Local ? RTLD_LOCAL : RTLD_GLOBAL));

lib/Support/Windows/DynamicLibrary.inc

 
 //===----------------------------------------------------------------------===//
 //=== WARNING: Implementation here must contain only Win32 specific code
 //===          and must not be UNIX code.
 //===----------------------------------------------------------------------===//
 
 
 DynamicLibrary::HandleSet::~HandleSet() {
-  for (void *Handle : llvm::reverse_range(Handles))
-    FreeLibrary(HMODULE(Handle));
+  for (DynamicLibrary &DL : reverse_range(Handles)) {
+    assert(DL.Data != &DynamicLibrary::Invalid);
+    FreeLibrary(HMODULE(DL.Data));
+    DL.Data = &DynamicLibrary::Invalid;
+  }
+  if (Process)
+    Process.Data = &DynamicLibrary::Invalid;
 
-  // 'Process' should not be released on Windows.
-  assert((!Process || Process==this) && "Bad Handle");
   // llvm_shutdown called, Return to default
   DynamicLibrary::SearchOrder = DynamicLibrary::SO_Linker;
 }
 
 void *DynamicLibrary::HandleSet::DLOpen(const char *File, std::string *Err,
                                         bool /*Local*/) {
   // Create the instance and return it to be the *Process* handle
   // simillar to dlopen(NULL, RTLD_LAZY|RTLD_GLOBAL)
static DynamicLibrary::HandleSet *IsOpenedHandlesInstance(void *Handle) {
   if (!OpenedHandles.isConstructed())
     return nullptr;
   DynamicLibrary::HandleSet &Inst = *OpenedHandles;
   return Handle == &Inst ? &Inst : nullptr;
 }
 
 void DynamicLibrary::HandleSet::DLClose(void *Handle) {
   if (HandleSet* HS = IsOpenedHandlesInstance(Handle))
-    HS->Process = nullptr; // Just drop the *Process* handle.
+    HS->Process.Data = &DynamicLibrary::Invalid; // Invalidate the fake handle.
   else
     FreeLibrary((HMODULE)Handle);
 }
 
 static bool GetProcessModules(HANDLE H, DWORD &Bytes, HMODULE *Data = nullptr) {
   // EnumProcessModules will fail on Windows 64 while some versions of
   // MingW-32 don't have EnumProcessModulesEx.
   if (

unittests/Support/DynamicLibrary/DynamicLibraryTest.cpp

 static const char *OverloadTestA() { return "OverloadCall"; }
 
 std::string StdString(const char *Ptr) { return Ptr ? Ptr : ""; }
 
 static void TestOverload(bool RTLocal = false) {
   {
     std::string Err;
     llvm_shutdown_obj Shutdown;
-    DynamicLibrary DL =
+    DynamicLibrary *DL =
         DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err, RTLocal);
-    EXPECT_TRUE(DL.isValid());
+    EXPECT_TRUE(DL != nullptr);
     EXPECT_TRUE(Err.empty());
 
-    GetString GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
+    GetString GS = FuncPtr<GetString>(DL->getAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS != &TestA);
     EXPECT_EQ(StdString(GS()), "LibCall");
 
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS != &TestA);
     EXPECT_EQ(StdString(GS()), "LibCall");
 
     DL = DynamicLibrary::getPermanentLibrary(nullptr, &Err);
-    EXPECT_TRUE(DL.isValid());
+    EXPECT_TRUE(DL != nullptr);
     EXPECT_TRUE(Err.empty());
 
     // Test overloading local symbols does not occur by default
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS == &TestA);
     EXPECT_EQ(StdString(GS()), "ProcessCall");
 
-    GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
+    GS = FuncPtr<GetString>(DL->getAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS == &TestA);
     EXPECT_EQ(StdString(GS()), "ProcessCall");
 
     // Test overloading by forcing a priority when searching for a symbol
     if (RTLocal) {
       // SetStrings un-resolved because RTLocal
       SetStrings SS = FuncPtr<SetStrings>(
           DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
if (RTLocal) {
 
       // TestA resolved from Library first
       GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
       EXPECT_TRUE(GS != nullptr && GS != &TestA);
       EXPECT_EQ(StdString(GS()), "LibCall");
     }
 
     DynamicLibrary::AddSymbol("TestA", PtrFunc(&OverloadTestA));
-    GS = FuncPtr<GetString>(DL.getAddressOfSymbol("TestA"));
+    GS = FuncPtr<GetString>(DL->getAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS != &OverloadTestA);
 
     GS = FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol("TestA"));
     EXPECT_TRUE(GS != nullptr && GS == &OverloadTestA);
     EXPECT_EQ(StdString(GS()), "OverloadCall");
   }
   EXPECT_TRUE(FuncPtr<GetString>(DynamicLibrary::SearchForAddressOfSymbol(
                   "TestA")) == nullptr);

 }
 #endif
 
 TEST(DynamicLibrary, Shutdown) {
   std::string A, B;
   {
     std::string Err;
     llvm_shutdown_obj Shutdown;
-    DynamicLibrary DL =
+    DynamicLibrary *DL =
         DynamicLibrary::getPermanentLibrary(LibPath().c_str(), &Err);
-    EXPECT_TRUE(DL.isValid());
+    EXPECT_TRUE(DL != nullptr);
     EXPECT_TRUE(Err.empty());
 
     SetStrings SS = FuncPtr<SetStrings>(
         DynamicLibrary::SearchForAddressOfSymbol("SetStrings"));
     EXPECT_TRUE(SS != nullptr);
 
     SS(A, B);
     EXPECT_EQ(B, "Local::Local");
   }
   EXPECT_EQ(A, "Global::~Global");
   EXPECT_EQ(B, "Local::~Local");
   EXPECT_TRUE(FuncPtr<SetStrings>(DynamicLibrary::SearchForAddressOfSymbol(
                   "SetStrings")) == nullptr);
 }
 
+TEST(DynamicLibrary, Scope) {
+  std::string A, B;
+  {
+    std::string Err;
+    DynamicLibrary DL(LibPath().c_str(), &Err);
+    EXPECT_TRUE(DL.isValid());
+    EXPECT_TRUE(Err.empty());
+
+    SetStrings SS = FuncPtr<SetStrings>(DL.getAddressOfSymbol("SetStrings"));
+    EXPECT_TRUE(SS != nullptr);
+
+    SS(A, B);
+    EXPECT_EQ(B, "Local::Local");
+  }
+  EXPECT_EQ(A, "Global::~Global");
+  EXPECT_EQ(B, "Local::~Local");
+}
+
 #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