llvm/lib/Support/DynamicLibrary.cpp

   1 //===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 //  This file implements the operating system DynamicLibrary concept.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/Support/DynamicLibrary.h"
  14 #include "llvm-c/Support.h"
  15 #include "llvm/ADT/STLExtras.h"
  16 #include "llvm/ADT/StringMap.h"
  17 #include "llvm/Config/config.h"
  18 #include "llvm/Support/Mutex.h"
  19 #include <vector>
  20
  21 using namespace llvm;
  22 using namespace llvm::sys;
  23
  24 // All methods for HandleSet should be used holding SymbolsMutex.
  25 class DynamicLibrary::HandleSet {
  26   typedef std::vector<void *> HandleList;
  27   HandleList Handles;
  28   void *Process = nullptr;
  29
  30 public:
  31   static void *DLOpen(const char *Filename, std::string *Err);
  32   static void DLClose(void *Handle);
  33   static void *DLSym(void *Handle, const char *Symbol);
  34
  35   HandleSet() = default;
  36   ~HandleSet();
  37
  38   HandleList::iterator Find(void *Handle) { return find(Handles, Handle); }
  39
  40   bool Contains(void *Handle) {
  41     return Handle == Process || Find(Handle) != Handles.end();
  42   }
  43
  44   bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true,
  45                   bool AllowDuplicates = false) {
  46 #ifdef _WIN32
  47     assert((Handle == this ? IsProcess : !IsProcess) && "Bad Handle.");
  48 #endif
  49     assert((!AllowDuplicates || !CanClose) &&
  50            "CanClose must be false if AllowDuplicates is true.");
  51
  52     if (LLVM_LIKELY(!IsProcess)) {
  53       if (!AllowDuplicates && Find(Handle) != Handles.end()) {
  54         if (CanClose)
  55           DLClose(Handle);
  56         return false;
  57       }
  58       Handles.push_back(Handle);
  59     } else {
  60 #ifndef _WIN32
  61       if (Process) {
  62         if (CanClose)
  63           DLClose(Process);
  64         if (Process == Handle)
  65           return false;
  66       }
  67 #endif
  68       Process = Handle;
  69     }
  70     return true;
  71   }
  72
  73   void CloseLibrary(void *Handle) {
  74     DLClose(Handle);
  75     HandleList::iterator it = Find(Handle);
  76     if (it != Handles.end()) {
  77       Handles.erase(it);
  78     }
  79   }
  80
  81   void *LibLookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
  82     if (Order & SO_LoadOrder) {
  83       for (void *Handle : Handles) {
  84         if (void *Ptr = DLSym(Handle, Symbol))
  85           return Ptr;
  86       }
  87     } else {
  88       for (void *Handle : llvm::reverse(Handles)) {
  89         if (void *Ptr = DLSym(Handle, Symbol))
  90           return Ptr;
  91       }
  92     }
  93     return nullptr;
  94   }
  95
  96   void *Lookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
  97     assert(!((Order & SO_LoadedFirst) && (Order & SO_LoadedLast)) &&
  98            "Invalid Ordering");
  99
 100     if (!Process || (Order & SO_LoadedFirst)) {
 101       if (void *Ptr = LibLookup(Symbol, Order))
 102         return Ptr;
 103     }
 104     if (Process) {
 105       // Use OS facilities to search the current binary and all loaded libs.
 106       if (void *Ptr = DLSym(Process, Symbol))
 107         return Ptr;
 108
 109       // Search any libs that might have been skipped because of RTLD_LOCAL.
 110       if (Order & SO_LoadedLast) {
 111         if (void *Ptr = LibLookup(Symbol, Order))
 112           return Ptr;
 113       }
 114     }
 115     return nullptr;
 116   }
 117 };
 118
 119 namespace {
 120
 121 struct Globals {
 122   // Collection of symbol name/value pairs to be searched prior to any
 123   // libraries.
 124   llvm::StringMap<void *> ExplicitSymbols;
 125   // Collections of known library handles.
 126   DynamicLibrary::HandleSet OpenedHandles;
 127   DynamicLibrary::HandleSet OpenedTemporaryHandles;
 128   // Lock for ExplicitSymbols, OpenedHandles, and OpenedTemporaryHandles.
 129   llvm::sys::SmartMutex<true> SymbolsMutex;
 130 };
 131
 132 Globals &getGlobals() {
 133   static Globals G;
 134   return G;
 135 }
 136
 137 } // namespace
 138
 139 #ifdef _WIN32
 140
 141 #include "Windows/DynamicLibrary.inc"
 142
 143 #else
 144
 145 #include "Unix/DynamicLibrary.inc"
 146
 147 #endif
 148
 149 char DynamicLibrary::Invalid;
 150 DynamicLibrary::SearchOrdering DynamicLibrary::SearchOrder =
 151     DynamicLibrary::SO_Linker;
 152
 153 namespace llvm {
 154 void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
 155   return DoSearch(SymbolName); // DynamicLibrary.inc
 156 }
 157 } // namespace llvm
 158
 159 void DynamicLibrary::AddSymbol(StringRef SymbolName, void *SymbolValue) {
 160   auto &G = getGlobals();
 161   SmartScopedLock<true> Lock(G.SymbolsMutex);
 162   G.ExplicitSymbols[SymbolName] = SymbolValue;
 163 }
 164
 165 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
 166                                                    std::string *Err) {
 167   auto &G = getGlobals();
 168   void *Handle = HandleSet::DLOpen(FileName, Err);
 169   if (Handle != &Invalid) {
 170     SmartScopedLock<true> Lock(G.SymbolsMutex);
 171     G.OpenedHandles.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
 172   }
 173
 174   return DynamicLibrary(Handle);
 175 }
 176
 177 DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,
 178                                                    std::string *Err) {
 179   auto &G = getGlobals();
 180   SmartScopedLock<true> Lock(G.SymbolsMutex);
 181   // If we've already loaded this library, tell the caller.
 182   if (!G.OpenedHandles.AddLibrary(Handle, /*IsProcess*/ false,
 183                                   /*CanClose*/ false))
 184     *Err = "Library already loaded";
 185
 186   return DynamicLibrary(Handle);
 187 }
 188
 189 DynamicLibrary DynamicLibrary::getLibrary(const char *FileName,
 190                                           std::string *Err) {
 191   assert(FileName && "Use getPermanentLibrary() for opening process handle");
 192   void *Handle = HandleSet::DLOpen(FileName, Err);
 193   if (Handle != &Invalid) {
 194     auto &G = getGlobals();
 195     SmartScopedLock<true> Lock(G.SymbolsMutex);
 196     G.OpenedTemporaryHandles.AddLibrary(Handle, /*IsProcess*/ false,
 197                                         /*CanClose*/ false,
 198                                         /*AllowDuplicates*/ true);
 199   }
 200   return DynamicLibrary(Handle);
 201 }
 202
 203 void DynamicLibrary::closeLibrary(DynamicLibrary &Lib) {
 204   auto &G = getGlobals();
 205   SmartScopedLock<true> Lock(G.SymbolsMutex);
 206   if (Lib.isValid()) {
 207     G.OpenedTemporaryHandles.CloseLibrary(Lib.Data);
 208     Lib.Data = &Invalid;
 209   }
 210 }
 211
 212 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
 213   if (!isValid())
 214     return nullptr;
 215   return HandleSet::DLSym(Data, SymbolName);
 216 }
 217
 218 void *DynamicLibrary::SearchForAddressOfSymbol(const char *SymbolName) {
 219   {
 220     auto &G = getGlobals();
 221     SmartScopedLock<true> Lock(G.SymbolsMutex);
 222
 223     // First check symbols added via AddSymbol().
 224     StringMap<void *>::iterator i = G.ExplicitSymbols.find(SymbolName);
 225
 226     if (i != G.ExplicitSymbols.end())
 227       return i->second;
 228
 229     // Now search the libraries.
 230     if (void *Ptr = G.OpenedHandles.Lookup(SymbolName, SearchOrder))
 231       return Ptr;
 232     if (void *Ptr = G.OpenedTemporaryHandles.Lookup(SymbolName, SearchOrder))
 233       return Ptr;
 234   }
 235
 236   return llvm::SearchForAddressOfSpecialSymbol(SymbolName);
 237 }
 238
 239 //===----------------------------------------------------------------------===//
 240 // C API.
 241 //===----------------------------------------------------------------------===//
 242
 243 LLVMBool LLVMLoadLibraryPermanently(const char *Filename) {
 244   return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);
 245 }
 246
 247 void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
 248   return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);
 249 }
 250
 251 void LLVMAddSymbol(const char *symbolName, void *symbolValue) {
 252   return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);
 253 }