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 SmartScopedLock<true> Lock(*SymbolsMutex); 131 void *Handle = HandleSet::DLOpen(FileName, Err); 132 if (Handle != &Invalid) 133 OpenedHandles->AddLibrary(Handle, /*IsProcess*/ FileName == nullptr); 134 135 return DynamicLibrary(Handle); 136 } 137 138 DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle, 139 std::string *Err) { 140 SmartScopedLock<true> Lock(*SymbolsMutex); 141 // If we've already loaded this library, tell the caller. 142 if (!OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false)) 143 *Err = "Library already loaded"; 144 145 return DynamicLibrary(Handle); 146 } 147 148 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) { 149 if (!isValid()) 150 return nullptr; 151 return HandleSet::DLSym(Data, SymbolName); 152 } 153 154 void *DynamicLibrary::SearchForAddressOfSymbol(const char *SymbolName) { 155 { 156 SmartScopedLock<true> Lock(*SymbolsMutex); 157 158 // First check symbols added via AddSymbol(). 159 if (ExplicitSymbols.isConstructed()) { 160 StringMap<void *>::iterator i = ExplicitSymbols->find(SymbolName); 161 162 if (i != ExplicitSymbols->end()) 163 return i->second; 164 } 165 166 // Now search the libraries. 167 if (OpenedHandles.isConstructed()) { 168 if (void *Ptr = OpenedHandles->Lookup(SymbolName)) 169 return Ptr; 170 } 171 } 172 173 return llvm::SearchForAddressOfSpecialSymbol(SymbolName); 174 } 175 176 //===----------------------------------------------------------------------===// 177 // C API. 178 //===----------------------------------------------------------------------===// 179 180 LLVMBool LLVMLoadLibraryPermanently(const char *Filename) { 181 return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename); 182 } 183 184 void *LLVMSearchForAddressOfSymbol(const char *symbolName) { 185 return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName); 186 } 187 188 void LLVMAddSymbol(const char *symbolName, void *symbolValue) { 189 return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue); 190 } 191