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 }
196