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/DenseSet.h"
16 #include "llvm/ADT/STLExtras.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 _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 _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 *LibLookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
77     if (Order & SO_LoadOrder) {
78       for (void *Handle : Handles) {
79         if (void *Ptr = DLSym(Handle, Symbol))
80           return Ptr;
81       }
82     } else {
83       for (void *Handle : llvm::reverse(Handles)) {
84         if (void *Ptr = DLSym(Handle, Symbol))
85           return Ptr;
86       }
87     }
88     return nullptr;
89   }
90 
91   void *Lookup(const char *Symbol, DynamicLibrary::SearchOrdering Order) {
92     assert(!((Order & SO_LoadedFirst) && (Order & SO_LoadedLast)) &&
93            "Invalid Ordering");
94 
95     if (!Process || (Order & SO_LoadedFirst)) {
96       if (void *Ptr = LibLookup(Symbol, Order))
97         return Ptr;
98     }
99     if (Process) {
100       // Use OS facilities to search the current binary and all loaded libs.
101       if (void *Ptr = DLSym(Process, Symbol))
102         return Ptr;
103 
104       // Search any libs that might have been skipped because of RTLD_LOCAL.
105       if (Order & SO_LoadedLast) {
106         if (void *Ptr = LibLookup(Symbol, Order))
107           return Ptr;
108       }
109     }
110     return nullptr;
111   }
112 };
113 
114 namespace {
115 // Collection of symbol name/value pairs to be searched prior to any libraries.
116 static llvm::ManagedStatic<llvm::StringMap<void *>> ExplicitSymbols;
117 // Collection of known library handles.
118 static llvm::ManagedStatic<DynamicLibrary::HandleSet> OpenedHandles;
119 // Lock for ExplicitSymbols and OpenedHandles.
120 static llvm::ManagedStatic<llvm::sys::SmartMutex<true>> SymbolsMutex;
121 }
122 
123 #ifdef _WIN32
124 
125 #include "Windows/DynamicLibrary.inc"
126 
127 #else
128 
129 #include "Unix/DynamicLibrary.inc"
130 
131 #endif
132 
133 char DynamicLibrary::Invalid;
134 DynamicLibrary::SearchOrdering DynamicLibrary::SearchOrder =
135     DynamicLibrary::SO_Linker;
136 
137 namespace llvm {
138 void *SearchForAddressOfSpecialSymbol(const char *SymbolName) {
139   return DoSearch(SymbolName); // DynamicLibrary.inc
140 }
141 }
142 
143 void DynamicLibrary::AddSymbol(StringRef SymbolName, void *SymbolValue) {
144   SmartScopedLock<true> Lock(*SymbolsMutex);
145   (*ExplicitSymbols)[SymbolName] = SymbolValue;
146 }
147 
148 DynamicLibrary DynamicLibrary::getPermanentLibrary(const char *FileName,
149                                                    std::string *Err) {
150   // Force OpenedHandles to be added into the ManagedStatic list before any
151   // ManagedStatic can be added from static constructors in HandleSet::DLOpen.
152   HandleSet& HS = *OpenedHandles;
153 
154   void *Handle = HandleSet::DLOpen(FileName, Err);
155   if (Handle != &Invalid) {
156     SmartScopedLock<true> Lock(*SymbolsMutex);
157     HS.AddLibrary(Handle, /*IsProcess*/ FileName == nullptr);
158   }
159 
160   return DynamicLibrary(Handle);
161 }
162 
163 DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,
164                                                    std::string *Err) {
165   SmartScopedLock<true> Lock(*SymbolsMutex);
166   // If we've already loaded this library, tell the caller.
167   if (!OpenedHandles->AddLibrary(Handle, /*IsProcess*/false, /*CanClose*/false))
168     *Err = "Library already loaded";
169 
170   return DynamicLibrary(Handle);
171 }
172 
173 void *DynamicLibrary::getAddressOfSymbol(const char *SymbolName) {
174   if (!isValid())
175     return nullptr;
176   return HandleSet::DLSym(Data, SymbolName);
177 }
178 
179 void *DynamicLibrary::SearchForAddressOfSymbol(const char *SymbolName) {
180   {
181     SmartScopedLock<true> Lock(*SymbolsMutex);
182 
183     // First check symbols added via AddSymbol().
184     if (ExplicitSymbols.isConstructed()) {
185       StringMap<void *>::iterator i = ExplicitSymbols->find(SymbolName);
186 
187       if (i != ExplicitSymbols->end())
188         return i->second;
189     }
190 
191     // Now search the libraries.
192     if (OpenedHandles.isConstructed()) {
193       if (void *Ptr = OpenedHandles->Lookup(SymbolName, SearchOrder))
194         return Ptr;
195     }
196   }
197 
198   return llvm::SearchForAddressOfSpecialSymbol(SymbolName);
199 }
200 
201 //===----------------------------------------------------------------------===//
202 // C API.
203 //===----------------------------------------------------------------------===//
204 
205 LLVMBool LLVMLoadLibraryPermanently(const char *Filename) {
206   return llvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);
207 }
208 
209 void *LLVMSearchForAddressOfSymbol(const char *symbolName) {
210   return llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);
211 }
212 
213 void LLVMAddSymbol(const char *symbolName, void *symbolValue) {
214   return llvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);
215 }
216