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