contrib/llvm/lib/Support/DynamicLibrary.cpp

   1 //===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 //  This file implements the operating system DynamicLibrary concept.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Support/DynamicLibrary.h"
  15 #include "llvm-c/Support.h"
  16 #include "llvm/ADT/DenseSet.h"
  17 #include "llvm/ADT/StringMap.h"
  18 #include "llvm/Config/config.h"
  19 #include "llvm/Support/ManagedStatic.h"
  20 #include "llvm/Support/Mutex.h"
  21 #include <cstdio>
  22 #include <cstring>
  23 #include <vector>
  24
  25 using namespace llvm;
  26 using namespace llvm::sys;
  27
  28 // All methods for HandleSet should be used holding SymbolsMutex.
  29 class DynamicLibrary::HandleSet {
  30   typedef std::vector<void *> HandleList;
  31   HandleList Handles;
  32   void *Process;
  33
  34 public:
  35   static void *DLOpen(const char *Filename, std::string *Err);
  36   static void DLClose(void *Handle);
  37   static void *DLSym(void *Handle, const char *Symbol);
  38
  39   HandleSet() : Process(nullptr) {}
  40   ~HandleSet();
  41
  42   HandleList::iterator Find(void *Handle) {
  43     return std::find(Handles.begin(), Handles.end(), Handle);
  44   }
  45
  46   bool Contains(void *Handle) {
  47     return Handle == Process || Find(Handle) != Handles.end();
  48   }
  49
  50   bool AddLibrary(void *Handle, bool IsProcess = false, bool CanClose = true) {
  51 #ifdef LLVM_ON_WIN32
  52     assert((Handle == this ? IsProcess : !IsProcess) && "Bad Handle.");
  53 #endif
  54
  55     if (LLVM_LIKELY(!IsProcess)) {
  56       if (Find(Handle) != Handles.end()) {
  57         if (CanClose)
  58           DLClose(Handle);
  59         return false;
  60       }
  61       Handles.push_back(Handle);
  62     } else {
  63 #ifndef LLVM_ON_WIN32
  64       if (Process) {
  65         if (CanClose)
  66           DLClose(Process);
  67         if (Process == Handle)
  68           return false;
  69       }
  70 #endif
  71       Process = Handle;
  72     }
  73     return true;
  74   }
  75
  76   void *Lookup(const char *Symbol) {
  77     // Process handle gets first try.
  78     if (Process) {
  79       if (void *Ptr = DLSym(Process, Symbol))
  80         return Ptr;
  81 #ifndef NDEBUG
  82       for (void *Handle : Handles)
  83         assert(!DLSym(Handle, Symbol) && "Symbol exists in non process handle");
  84 #endif
  85     } else {
  86       // Iterate in reverse, so newer libraries/symbols override older.
  87       for (auto &&I = Handles.rbegin(), E = Handles.rend(); I != E; ++I) {
  88         if (void *Ptr = DLSym(*I, Symbol))
  89           return Ptr;
  90       }
  91     }
  92     return nullptr;
  93   }
  94 };
  95
  96 namespace {
  97 // Collection of symbol name/value pairs to be searched prior to any libraries.
  98 static llvm::ManagedStatic<llvm::StringMap<void *>> ExplicitSymbols;
  99 // Collection of known library handles.
 100 static llvm::ManagedStatic<DynamicLibrary::HandleSet> OpenedHandles;
 101 // Lock for ExplicitSymbols and OpenedHandles.
 102 static llvm::ManagedStatic<llvm::sys::SmartMutex<true>> SymbolsMutex;
 103 }
 104
 105 #ifdef LLVM_ON_WIN32
 106
 107 #include "Windows/DynamicLibrary.inc"
 108
 109 #else
 110
 111 #include "Unix/DynamicLibrary.inc"
 112
 113 #endif
 114
 115 char DynamicLibrary::Invalid;
 116
 117 namespace llvm {
 118 void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
 119   return DoSearch(SymbolName); // DynamicLibrary.inc
 120 }
 121 }
 122
 123 void DynamicLibrary::AddSymbol(StringRef SymbolName, void *SymbolValue) {
 124   SmartScopedLock<true> Lock(*SymbolsMutex);
 125   (*ExplicitSymbols)[SymbolName] = SymbolValue;
 126 }
 127
 128 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
 129                                                    std::string *Err) {
 130   // Force OpenedHandles to be added into the ManagedStatic list before any
 131   // ManagedStatic can be added from static constructors in HandleSet::DLOpen.
 132   HandleSet& HS = *OpenedHandles;
 133
 134   void *Handle = HandleSet::DLOpen(FileName, Err);
 135   if (Handle != &Invalid) {
 136     SmartScopedLock<true> Lock(*SymbolsMutex);
 137     HS.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
 138   }
 139
 140   return DynamicLibrary(Handle);
 141 }
 142
 143 DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,
 144                                                    std::string *Err) {
 145   SmartScopedLock<true> Lock(*SymbolsMutex);
 146   // If we've already loaded this library, tell the caller.
 147   if (!OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false))
 148     *Err = "Library already loaded";
 149
 150   return DynamicLibrary(Handle);
 151 }
 152
 153 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
 154   if (!isValid())
 155     return nullptr;
 156   return HandleSet::DLSym(Data, SymbolName);
 157 }
 158
 159 void *DynamicLibrary::SearchForAddressOfSymbol(const char *SymbolName) {
 160   {
 161     SmartScopedLock<true> Lock(*SymbolsMutex);
 162
 163     // First check symbols added via AddSymbol().
 164     if (ExplicitSymbols.isConstructed()) {
 165       StringMap<void *>::iterator i = ExplicitSymbols->find(SymbolName);
 166
 167       if (i != ExplicitSymbols->end())
 168         return i->second;
 169     }
 170
 171     // Now search the libraries.
 172     if (OpenedHandles.isConstructed()) {
 173       if (void *Ptr = OpenedHandles->Lookup(SymbolName))
 174         return Ptr;
 175     }
 176   }
 177
 178   return llvm::SearchForAddressOfSpecialSymbol(SymbolName);
 179 }
 180
 181 //===----------------------------------------------------------------------===//
 182 // C API.
 183 //===----------------------------------------------------------------------===//
 184
 185 LLVMBool LLVMLoadLibraryPermanently(const char *Filename) {
 186   return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);
 187 }
 188
 189 void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
 190   return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);
 191 }
 192
 193 void LLVMAddSymbol(const char *symbolName, void *symbolValue) {
 194   return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);
 195 }